serial_no int64 1 24.2k | cuda_source stringlengths 11 9.01M |
|---|---|
10,201 | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
void query_device() {
int deviceCount { 0 };
cudaGetDeviceCount(&deviceCount);
if (deviceCount == 0) {
std::cout << "No CUDA support device found" << std::endl;
}
int devNo { 0 };
cudaDeviceProp iProp;
cudaGetDeviceProperties(&iProp, devNo);
std::cout << "Device " << devNo << ": " << iProp.name << std::endl;
std::cout << " Number of multiprocessors: " << iProp.multiProcessorCount
<< std::endl;
std::cout << " clock rate: " << iProp.clockRate << std::endl;
std::cout << " Compute capability: " << iProp.major << "." << iProp.minor
<< std::endl;
std::cout << " Total amount of global memory: "
<< iProp.totalGlobalMem / 1024 << " KB" << std::endl;
std::cout << " Total amount of constant memory: "
<< iProp.totalConstMem / 1024 << " KB" << std::endl;
std::cout << " Total amount of shared memory per block: "
<< iProp.sharedMemPerBlock / 1024 << " KB" << std::endl;
std::cout << " Total number of registers available per block: "
<< iProp.regsPerBlock << std::endl;
std::cout << " Warp size: " << iProp.warpSize << std::endl;
std::cout << " Maximum number of threads per block: "
<< iProp.maxThreadsPerBlock << std::endl;
std::cout << " Maximum Grid size: (" << iProp.maxGridSize[0] << ", "
<< iProp.maxGridSize[1] << ", " << iProp.maxGridSize[2] << ")"
<< std::endl;
std::cout << " Maximum block dimension: (" << iProp.maxThreadsDim[0]
<< ", " << iProp.maxThreadsDim[1] << ", " << iProp.maxThreadsDim[2]
<< ")" << std::endl;
}
int main() {
query_device();
return 0;
}
|
10,202 | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#define SCREEN_WIDTH 6
#define SCREEN_HEIGHT 4
__global__ void GPU_kernel(int maxcount)
{
int x = threadIdx.x + (blockIdx.x * blockDim.x);
int y = threadIdx.y + (blockIdx.y * blockDim.y);
int actual_index = x + (y * blockDim.x * gridDim.x);
if (actual_index >= maxcount) return;
printf("Actual pixel: %i , %i\n", x, y);
}
int main(void)
{
int ThreadsX = 3, ThreadsY = 2;
dim3 blockarray(( SCREEN_WIDTH + ThreadsX - 1) / ThreadsX, (SCREEN_HEIGHT + ThreadsY - 1) / ThreadsY);
dim3 threadarray(ThreadsX, ThreadsY);
GPU_kernel <<< blockarray, threadarray >>> ( SCREEN_WIDTH * SCREEN_HEIGHT);
cudaDeviceSynchronize();
printf("Execution done!\n");
return 0;
}
|
10,203 | #include "includes.h"
__global__ void factorKernel(float *w, int N)
{
int ix = blockIdx.x * blockDim.x + threadIdx.x;
int idx = ix * 2;
int izx = N + idx;
const float pi = 3.141592653589793238462643383;
float aw = (2.0 * pi) / (float)N;
float arg = aw * (float)ix;
/* Twiddle factors are symmetric along N/2. with change in sign, due to 180 degree phase change */
if (idx < N) {
w[idx] = cos(arg);
w[idx + 1] = sin(arg);
w[izx] = (-1) * w[idx];
w[izx+1] = (-1) * w[idx + 1];
}
} |
10,204 | #include <cuda.h>
#include <cuda_runtime.h>
#include <device_launch_parameters.h>
#include <stdlib.h>
#include "Fp.cu"
#include <stdio.h>
#define NUM_R_POINTS 32 // Must be a power of 2
#define R_POINT_MASK (NUM_R_POINTS - 1)
/**
* Bit mask for identifying distinguished points
*/
__constant__ unsigned int _MASK[ 2 ];
/**
* The X coordinates of the R points
*/
__constant__ unsigned int _rx[ 10 * NUM_R_POINTS ];
/**
* The Y coordinates of the Y points
*/
__constant__ unsigned int _ry[ 10 * NUM_R_POINTS ];
/**
* Shared memory to hold the R points
*/
__shared__ unsigned int _shared_rx[ 10 * NUM_R_POINTS ];
__shared__ unsigned int _shared_ry[ 10 * NUM_R_POINTS ];
/**
* Point at infinity
*/
__device__ unsigned int _pointAtInfinity[10] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff};
/**
* Reads Rx[i] from shared memory
*/
template<int N> __device__ void getRX(int index, unsigned int *rx)
{
for(int i = 0; i < N; i++) {
rx[i] = _shared_rx[32 * i + index];
}
}
/**
* Reads Ry[i] from shared memory
*/
template<int N> __device__ void getRY(int index, unsigned int *ry)
{
for(int i = 0; i < N; i++) {
ry[ i ] = _shared_ry[32 * i + index];
}
}
/**
* Reads Rx and Ry from constant memory and writes them to shared memory
*/
__device__ void initSharedMem(unsigned int len)
{
if(threadIdx.x == 0) {
for(int i = 0; i < len; i++) {
for(int j = 0; j < 32; j++) {
_shared_rx[i * 32 + j] = _rx[ len * j + i];
_shared_ry[i * 32 + j] = _ry[ len * j + i];
}
}
}
__syncthreads();
}
template<int N> __device__ void doMultiplyStep(const unsigned int *aMultiplier, const unsigned int *bMultiplier,
const unsigned int *gx, const unsigned int *gy,
const unsigned int *qx, const unsigned int *qy,
const unsigned int *gqx, const unsigned int *gqy,
unsigned int *xAra, unsigned int *yAra,
unsigned int *diffBuf, unsigned int *chainBuf,
int step, unsigned int pointsPerThread)
{
unsigned int product[N] = {0};
product[0] = 1;
unsigned int mask = 1 << (step % 32);
int word = step / 32;
// To compute (Px - Qx)^-1, multiply together all the differences and then perfom
// a single inversion. After each multiplication, store the product.
for(int i = 0; i < pointsPerThread; i++) {
unsigned int bpx[N];
unsigned int x[N];
readBigInt<N>(xAra, i, x);
unsigned int diff[N];
// For point at infinity we set the difference as 2 so the math still
// works out
unsigned int am = readBigIntWord<N>(aMultiplier, i, word);
unsigned int bm = readBigIntWord<N>(bMultiplier, i, word);
if( (am | bm) & mask == 0 || equalTo<N>(x, _pointAtInfinity) ) {
zero<N>(diff);
diff[0] = 2;
} else {
if( (am & ~bm) & mask ) {
copy<N>(&gx[step * N], bpx);
} else if( (~am & bm) & mask) {
copy<N>(&qx[step * N], bpx);
} else {
copy<N>(&gqx[step * N], bpx);
}
subModP<N>(x, bpx, diff);
}
writeBigInt<N>(diffBuf, i, diff);
multiplyModP<N>(product, diff, product);
writeBigInt<N>(chainBuf, i, product);
}
// Compute the inverse
unsigned int inverse[N];
inverseModP<N>(product, inverse);
// Multiply by the products stored perviously so that they are canceled out
for(int i = pointsPerThread - 1; i >= 0; i--) {
// Get the inverse of the last difference by multiplying the inverse of the product of all the differences
// with the product of all but the last difference
unsigned int invDiff[N];
if( i >= 1) {
unsigned int tmp[N];
readBigInt<N>(chainBuf, i - 1, tmp);
multiplyModP<N>(inverse, tmp, invDiff);
// Cancel out the last difference
readBigInt<N>(diffBuf, i, tmp);
multiplyModP<N>(inverse, tmp, inverse);
} else {
copy<N>(inverse, invDiff);
}
unsigned int am = readBigIntWord<N>( aMultiplier, i, word );
unsigned int bm = readBigIntWord<N>( bMultiplier, i, word );
if((am & mask) != 0 || (bm & mask) != 0 ) {
unsigned int px[N];
unsigned int py[N];
unsigned int bpx[N];
unsigned int bpy[N];
// Select G, Q, or G+Q
if((am & ~bm) & mask ) {
copy<N>(&gx[step *N], bpx);
copy<N>(&gy[step *N], bpy);
} else if((~am & bm) & mask) {
copy<N>(&qx[step *N], bpx);
copy<N>(&qy[step *N], bpy);
} else {
copy<N>(&gqx[step *N], bpx);
copy<N>(&gqy[step *N], bpy);
}
// Load the current point
readBigInt<N>(xAra, i, px);
readBigInt<N>(yAra, i, py);
if(equalTo<N>( px, _pointAtInfinity)) {
writeBigInt<N>(xAra, i, bpx);
writeBigInt<N>(yAra, i, bpy);
} else {
unsigned int s[N];
unsigned int rx[N];
unsigned int s2[N];
// s = Py - Qy / Px - Qx
subModP<N>(py, bpy, s);
multiplyModP<N>(invDiff, s, s);
squareModP<N>(s, s2);
// Rx = s^2 - Px - Qx
subModP<N>(s2, px, rx);
subModP<N>(rx, bpx, rx);
// Ry = -Py + s(Px - Rx)
unsigned int k[N];
subModP<N>(px, rx, k);
multiplyModP<N>(k, s, k);
unsigned int ry[N];
subModP<N>(k, py, ry);
writeBigInt<N>(xAra, i, rx);
writeBigInt<N>(yAra, i, ry);
}
}
}
}
/**
* Based on the bit values of a and b, G, Q, or (G+Q) will be added
*/
__global__ void startingPointGenKernel(const unsigned int *a, const unsigned int *b,
const unsigned int *gx, const unsigned int *gy,
const unsigned int *qx, const unsigned int *qy,
const unsigned int *gqx, const unsigned int *gqy,
unsigned int *rx, unsigned int *ry,
unsigned int *diffBuf, unsigned int *chainBuf,
int step, unsigned int pointsPerThread)
{
initFp();
initSharedMem(_PWORDS);
switch(_PWORDS) {
case 2:
doMultiplyStep<2>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
case 3:
doMultiplyStep<3>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
case 4:
doMultiplyStep<4>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
case 5:
doMultiplyStep<5>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
case 6:
doMultiplyStep<6>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
case 7:
doMultiplyStep<7>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
case 8:
doMultiplyStep<8>( a, b, gx, gy, qx, qy, gqx, gqy, rx, ry, diffBuf, chainBuf, step, pointsPerThread);
break;
}
}
/**
* Resets all points on the device to the point at infinity
*/
__device__ void resetPointsFunc(unsigned int *rx, unsigned int *ry, int pointsPerThread)
{
for(int i = 0; i < pointsPerThread; i++)
{
writeBigInt(rx, i, _pointAtInfinity, _PWORDS);
writeBigInt(ry, i, _pointAtInfinity, _PWORDS);
}
}
/**
* Kernel to reset all points on the device to the point at infinity
*/
__global__ void resetPointsKernel( unsigned int *rx, unsigned int *ry, int pointsPerThread)
{
resetPointsFunc(rx, ry, pointsPerThread);
}
/**
* Sets the number of distinguished bits to look for
*/
static cudaError_t setNumDistinguishedBits(unsigned int dBits)
{
unsigned int mask[2] = {0xffffffff, 0xffffffff};
if(dBits > 32) {
mask[ 1 ] >>= (32 - (dBits - 32));
} else {
mask[ 0 ] >>= (32 - dBits);
mask[ 1 ] = 0;
}
return cudaMemcpyToSymbol(_MASK, mask, sizeof(mask), 0, cudaMemcpyHostToDevice);
}
/**
* Subtract 2 from a big integer
*/
static void sub2(const unsigned int *a, unsigned int *c, int len)
{
unsigned int borrowOut = 0;
unsigned int borrowIn = 2;
for( int i = 0; i < len; i++ ) {
unsigned int d = a[ i ] - borrowIn;
if(d > a[i]) {
borrowOut = 1;
} else {
borrowOut = 0;
}
borrowIn = borrowOut;
c[i] = d;
}
}
/**
* Shift a big integer left by n bits
*/
static void shiftLeft(const unsigned int *a, int n, unsigned int *c, int len)
{
unsigned int out = 0;
unsigned int in = 0;
for(int i = 0; i < len; i++) {
out = a[i] >> (32 - n);
c[i] = a[i] << n;
c[i] |= in;
in = out;
}
}
/**
* Add two big integers
*/
static void addInt(const unsigned int *a, const unsigned int *b, unsigned int *c, int len)
{
unsigned int carryIn = 0;
unsigned int carryOut = 0;
for(int i = 0; i < len; i++) {
unsigned int s = a[i] + b[i];
if(s < a[i]) {
carryOut = 1;
} else {
carryOut = 0;
}
s += carryIn;
carryIn = carryOut;
c[i] = s;
}
}
/**
* Set parameters for the prime field library
*/
static cudaError_t setFpParameters(const unsigned int *pPtr, unsigned int pBits, const unsigned int *mPtr, unsigned int mBits)
{
cudaError_t cudaError = cudaSuccess;
unsigned int pWords = (pBits + 31) / 32;
unsigned int mWords = (mBits + 31) / 32;
unsigned int p2Words = (pBits + 1 + 31) / 32;
unsigned int p3Words = (pBits + 2 + 31) / 32;
unsigned int p[10] = {0};
unsigned int pTimes2[10] = {0};
unsigned int pTimes3[10] = {0};
unsigned int pMinus2[10] = {0};
// copy p into buffer
for(unsigned int i = 0; i < pWords; i++) {
p[i] = pPtr[i];
}
// compute p - 2
sub2(p, pMinus2, 10);
// compute 2 * p
shiftLeft(p, 1, pTimes2, 10);
// compute 3 * p
addInt(p, pTimes2, pTimes3, 10);
cudaError = cudaMemcpyToSymbol(_P_CONST, p, sizeof(unsigned int)*pWords, 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_PMINUS2_CONST, pMinus2, sizeof(unsigned int)*pWords, 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_M_CONST, mPtr, sizeof(unsigned int)*mWords, 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_PBITS_CONST, &pBits, sizeof(pBits), 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_2P_CONST, pTimes2, sizeof(unsigned int) * p2Words, 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_3P_CONST, pTimes3, sizeof(unsigned int) * p3Words, 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_PWORDS, &pWords, sizeof(unsigned int), 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_MWORDS, &mWords, sizeof(unsigned int), 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_MBITS_CONST, &mBits, sizeof(mBits), 0, cudaMemcpyHostToDevice);
end:
return cudaError;
}
/**
* Initialize device parameters
*/
cudaError_t initDeviceParams(const unsigned int *p, unsigned int pBits, const unsigned int *m, unsigned int mBits, unsigned int dBits)
{
cudaError_t cudaError = setFpParameters(p, pBits, m, mBits);
if(cudaError != cudaSuccess) {
goto end;
}
cudaError = setNumDistinguishedBits(dBits);
end:
return cudaError;
}
/**
* Copy a, b, Rx and Ry to constant memory
*/
cudaError_t copyRPointsToDevice(const unsigned int *rx, const unsigned int *ry, int length, int count)
{
cudaError_t cudaError = cudaSuccess;
size_t size = sizeof(unsigned int) * length * count;
cudaError = cudaMemcpyToSymbol(_rx, rx, size, 0, cudaMemcpyHostToDevice );
if( cudaError != cudaSuccess ) {
goto end;
}
cudaError = cudaMemcpyToSymbol(_ry, ry, size, 0, cudaMemcpyHostToDevice );
if( cudaError != cudaSuccess ) {
goto end;
}
end:
return cudaError;
}
cudaError_t multiplyAddG(unsigned int blocks, unsigned int threads, unsigned int pointsPerThread,
const unsigned int *a, const unsigned int *b,
const unsigned int *gx, const unsigned int *gy,
const unsigned int *qx, const unsigned int *qy,
const unsigned int *gqx, const unsigned int *gqy,
unsigned int *x, unsigned int *y,
unsigned int *diffBuf, unsigned int *chainBuf,
unsigned int step)
{
startingPointGenKernel<<<blocks, threads>>>(a, b, gx, gy, qx, qy, gqx, gqy, x, y, diffBuf, chainBuf, step, pointsPerThread);
return cudaDeviceSynchronize();
}
/**
* Reset all points to point at infinity
*/
cudaError_t resetPoints(unsigned int blocks, unsigned int threads, unsigned int pointsPerThread, unsigned int *rx, unsigned int *ry)
{
resetPointsKernel<<<blocks, threads>>>(rx, ry, pointsPerThread);
return cudaDeviceSynchronize();
}
void __device__ cuPrintBigInt(const unsigned int *x, int len)
{
for(int i = 0; i < len; i++) {
printf("%x ", x[i]);
}
printf("\n");
}
template<int N> __device__ void doStep(
unsigned int *xAra,
unsigned int *yAra,
unsigned int *diffBuf,
unsigned int *chainBuf,
unsigned int *blockFlags,
unsigned int *pointFlags,
unsigned int pointsInParallel) {
// Initalize to 1
unsigned int product[N] = {0};
product[0] = 1;
// Multiply differences together
for(int i = 0; i < pointsInParallel; i++) {
unsigned int x[N];
readBigInt<N>(xAra, i, x);
unsigned int rIdx = x[0] & R_POINT_MASK;
unsigned int diff[N];
unsigned int rx[N];
getRX<N>(rIdx, rx);
subModP<N>(x, rx, diff);
writeBigInt<N>(diffBuf, i, diff);
multiplyModP<N>(product, diff, product);
writeBigInt<N>(chainBuf, i, product);
}
// Compute inverse
unsigned int inverse[N];
inverseModP<N>(product, inverse);
// Extract inverse of the differences
for(int i = pointsInParallel - 1; i >= 0; i--) {
// Get the inverse of the last difference by multiplying the inverse of the product of all the differences
// with the product of all but the last difference
unsigned int invDiff[N];
if(i >= 1) {
unsigned int tmp[N];
readBigInt<N>(chainBuf, i-1, tmp);
multiplyModP<N>(inverse, tmp, invDiff);
// Cancel out the last difference
readBigInt<N>(diffBuf, i, tmp);
multiplyModP<N>(inverse, tmp, inverse);
} else {
copy<N>(inverse, invDiff);
}
unsigned int px[N];
unsigned int py[N];
readBigInt<N>(xAra, i, px);
readBigInt<N>(yAra, i, py);
unsigned int rIdx = px[0] & R_POINT_MASK;
unsigned int s[N];
unsigned int s2[N];
// s^2 = (Py - Qy / Px - Qx)^2
unsigned int ry[N];
getRY<N>(rIdx, ry);
subModP<N>(py, ry, s);
multiplyModP<N>(s, invDiff, s);
squareModP<N>(s, s2);
// Rx = s^2 - Px - Qx
unsigned int newX[N];
subModP<N>(s2, px, newX);
unsigned int rx[N];
getRX<N>(rIdx, rx);
subModP<N>(newX, rx, newX);
// Ry = -Py + s(Px - Rx)
unsigned int k[N];
subModP<N>(px, newX, k);
multiplyModP<N>(k, s, k);
unsigned int newY[N];
subModP<N>(k, py, newY);
// Write result to memory
writeBigInt<N>(xAra, i, newX);
writeBigInt<N>(yAra, i, newY);
// Check for distinguished point, set flag if found
if(((newX[ 0 ] & _MASK[ 0 ]) == 0) && ((newX[ 1 ] & _MASK[ 1 ]) == 0)) {
blockFlags[blockIdx.x] = 1;
pointFlags[gridDim.x * blockDim.x * i + blockIdx.x * blockDim.x + threadIdx.x] = 1;
}
}
}
template<int N> __global__ void doStepKernel( unsigned int *xAra,
unsigned int *yAra,
unsigned int *diffBuf,
unsigned int *chainBuf,
unsigned int *blockFlags,
unsigned int *pointFlags,
unsigned int pointsPerThread)
{
// Initialize shared memory constants
initFp();
initSharedMem(_PWORDS);
doStep<N>(xAra, yAra, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
}
cudaError_t initDeviceConstants(unsigned int numPoints)
{
cudaError_t cudaError = cudaSuccess;
cudaError = cudaMemcpyToSymbol(_NUM_POINTS, &numPoints, sizeof(unsigned int), 0, cudaMemcpyHostToDevice);
if(cudaError != cudaSuccess) {
goto end;
}
end:
return cudaSuccess;
}
cudaError_t cudaDoStep(int pLen,
int blocks,
int threads,
int pointsPerThread,
unsigned int *rx,
unsigned int *ry,
unsigned int *diffBuf,
unsigned int *chainBuf,
unsigned int *blockFlags,
unsigned int *pointFlags)
{
switch(pLen) {
case 1:
doStepKernel<1><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 2:
doStepKernel<2><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 3:
doStepKernel<3><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 4:
doStepKernel<4><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 5:
doStepKernel<5><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 6:
doStepKernel<6><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 7:
doStepKernel<7><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
case 8:
doStepKernel<8><<<blocks, threads>>>(rx, ry, diffBuf, chainBuf, blockFlags, pointFlags, pointsPerThread);
break;
default:
throw "Unsupported word size";
}
return cudaDeviceSynchronize();
}
|
10,205 | #include "includes.h"
__global__ void marshalling2(int *input_itemsets, int *tmp, int max_rows, int max_cols)
{
int i, j;
i = blockIdx.y*blockDim.y+threadIdx.y+max_rows;
j = blockIdx.x*blockDim.x+threadIdx.x;
if( i >= max_rows*2-1 || j >= max_cols) return;
if( j < max_cols-(i-max_rows+1)) {
tmp[i*max_cols+j] = input_itemsets[(max_rows-1-j)*max_cols+j+1+(i-max_rows)];
}
else {
tmp[i*max_cols+j] = 0;
}
} |
10,206 | #include "includes.h"
#define BLOCK_WIDTH 16
#define BLOCK_HEIGHT 16
#define SHARED_BLOCK_DIM 32
#define CHUNK_SIZE 512
#define cudaCheckError(ans) cudaAssert((ans), __FILE__, __LINE__);
__global__ void show(){
//printf("AAAAAAAAAAAAA\n");
/*for(int i=0;i<global_width*global_height;i++){
printf("%d\n",next_cu[i]);
}*/
} |
10,207 | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <thrust/sequence.h>
#include <iostream>
#define ISLAND 2
#define POPULATION 10
#define FACILITY 6
#define GENERATION 30
#define CROSSOVER 0.6
#define MUTATION 0.03
#define MIGRATION 5
#define INDIVIDUAL 5
#define H 3 // BAY height
#define W 2 // BAY width
void shuffle(int* facility);
int main(void){
srand(time(NULL));
int data[ISLAND][POPULATION][FACILITY]; // facility
short int bay[ISLAND][POPULATION][FACILITY-1]; //bay
thrust::device_vector<int> dev_data(ISLAND*POPULATION*FACILITY);
// thrust::device_vector<short int> bay[ISLAND][POPULATION][FACILITY];
// ***data***
// int ***data = NULL;
// data = (int ***)malloc(sizeof(int **)*ISLAND);
// for(int i=0;i<ISLAND;i++){
// data[i] = (int **)malloc(sizeof(int *)*POPULATION);
// }
//
// for(int i=0;i<ISLAND;i++){
// for(int p=0;p<POPULATION;p++){
// data[i][j] = (int *)malloc(sizeof(int)*FACILITY);
// }
// }
// ***data end***
int facility[FACILITY];
for(int i=0;i<ISLAND;i++){ // shuffle the sorted facility
printf("new island = %d\n", i);
for(int p=0;p<POPULATION;p++){
for(int t=0;t<FACILITY;t++){
facility[t] = t;
}
shuffle(facility);
// for(int t=0;t<FACILITY;t++){
// printf("%d ", facility[t]);
// }
for(int f=0;f<FACILITY;f++){
data[i][p][f] = facility[f];
std::cout << data[i][p][f] << " ";
}
std::cout << "\n" ;
for(int b=0;b<FACILITY-1;b++){
int j = rand() % 2;
bay[i][p][b] = j;
}
}
}
// throw to dev_data device memory
thrust::copy(&(data[0][0][0]), &(data[ISLAND-1][POPULATION-1][FACILITY-1]), dev_data.begin());
// read ther cost
FILE *fPtr;
fPtr=fopen("cost.txt","r");
int cost[FACILITY][FACILITY] = {0};
int temp[15][3]; // cost
for(int i=0;i<15;i++){
for(int a=0;a<3;a++){
fscanf(fPtr , "%d " , &temp[i][a]);
}
}
fclose(fPtr);
std::cout << "cost: " << std::endl;
for(int i=0;i<15;i++){ // 2 dimention cost
cost[temp[i][0]-1][temp[i][1]-1] = temp[i][2];
std::cout << temp[i][0] << " " << temp[i][1] << " " << temp[i][2] << std::endl;
}
std::cout << "\ndevice data: " << std::endl;
for(int i = 0; i < ISLAND; i++){
std::cout << "island: " << i << std::endl;
for(int p=0;p<POPULATION;p++){
for(int f=0;f<FACILITY;f++){
std::cout << dev_data[i+p+f] << " ";
}
std::cout << std::endl;
}
}
for(int g=0;g<GENERATION;g++){
printf("generation = %d\n", g);
thrust::device_vector<float> position;
} // generation loop end
return 0;
}
void shuffle(int* facility) { // ���ñƧǦn��facility
int i;
for(i = 0; i < FACILITY; i++) {
int j = rand() % FACILITY;
int tmp = facility[i];
facility[i] = facility[j];
facility[j] = tmp;
}
}
|
10,208 | #include <stdio.h>
#include <sys/time.h>
#include <cuda_runtime.h>
const float eps = 0.0001f;
const float dt = 0.01f;
const int N = 128 * 1024;
#define coord float3
__global__ void integrate(coord *new_p, coord *new_v, coord *p, coord *v,
int n, float dt)
{
int index = blockIdx.x * blockDim.x + threadIdx.x;
if (index >= n)
return;
coord body_pos = p[index];
coord body_vel = v[index];
coord f;
f.x = 0;
f.y = 0;
f.z = 0;
for (int i = 0; i < n; i++) {
coord pi = p[i];
coord r;
// Vector from p[i] to body
r.x = pi.x - body_pos.x;
r.y = pi.y - body_pos.y;
r.z = pi.z - body_pos.z;
float invDist = 1.0 / sqrtf(r.x * r.x + r.y * r.y + r.z * r.z + eps * eps);
float s = invDist * invDist * invDist;
// Add force of body i
f.x += r.x * s;
f.y += r.y * s;
f.z += r.z * s;
}
// Correct velocity
body_vel.x += f.x * dt;
body_vel.y += f.y * dt;
body_vel.z += f.z * dt;
body_pos.x += body_vel.x * dt;
body_pos.y += body_vel.y * dt;
body_pos.z += body_vel.z * dt;
new_p[index] = body_pos;
new_v[index] = body_vel;
}
double wtime()
{
struct timeval t;
gettimeofday(&t, NULL);
return (double)t.tv_sec + (double)t.tv_usec * 1E-6;
}
void init_rand(coord *v, int n)
{
for (int i = 0; i < n; i++) {
v[i].x = rand() / (float)RAND_MAX - 0.5f;
v[i].y = rand() / (float)RAND_MAX - 0.5f;
v[i].z = rand() / (float)RAND_MAX - 0.5f;
}
}
int main()
{
double tgpu = 0, tmem = 0;
size_t size = sizeof(coord) * N;
coord *p = (coord *)malloc(size);
coord *v = (coord *)malloc(size);
coord *d_p[2] = {NULL, NULL};
coord *d_v[2] = {NULL, NULL};
init_rand(p, N);
init_rand(v, N);
tmem = -wtime();
cudaMalloc((void **)&d_p[0], size);
cudaMalloc((void **)&d_p[1], size);
cudaMalloc((void **)&d_v[0], size);
cudaMalloc((void **)&d_v[1], size);
cudaMemcpy(d_p[0], p, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_v[0], v, size, cudaMemcpyHostToDevice);
tmem += wtime();
tgpu = -wtime();
int threadsPerBlock = 1024;
dim3 block(threadsPerBlock);
dim3 grid((N + threadsPerBlock - 1) / threadsPerBlock);
int index = 0;
for (int i = 0; i < 2; i++, index ^= 1) {
integrate<<<grid, block>>>(d_p[index ^ 1], d_v[index ^ 1], d_p[index], d_v[index], N, dt);
}
cudaDeviceSynchronize();
tgpu += wtime();
tmem -= wtime();
cudaMemcpy(p, d_p[index], size, cudaMemcpyDeviceToHost);
cudaMemcpy(v, d_v[index], size, cudaMemcpyDeviceToHost);
tmem += wtime();
/*
for (int i = 0; i < N; i++) {
printf("%4d: %f %f %f %f %f %f\n", i, p[i].x, p[i].y, p[i].z, v[i].x, v[i].y, v[i].z);
}
*/
printf("sizeof(coord) = %d\n", sizeof(coord));
printf("GPU version (sec.): %.6f\n", tgpu);
printf("Memory ops. (sec.): %.6f\n", tmem);
printf(" Total time (sec.): %.6f\n", tgpu + tmem);
cudaFree(d_p[0]);
cudaFree(d_p[1]);
cudaFree(d_v[0]);
cudaFree(d_v[1]);
free(p);
free(v);
cudaDeviceReset();
return 0;
}
|
10,209 | #include <cuda_runtime_api.h>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <random>
/*
WRITE CUDA KERNEL FOR COUNT HERE
*/
__global__ void scan_block_3(int *data, int *out, int *values, int *block_sums){
__shared__ int chunk_data[1024];
int start = 1024 * blockIdx.x;
int tid = threadIdx.x;
int gap = 1;
int start_size = 1024 >> 1;
int temp_block_sum = 0;
chunk_data[2*tid] = data[start+(2*tid)];
chunk_data[2*tid+1] = data[start+(2*tid+1)];
__syncthreads();
if (threadIdx.x == 0){
temp_block_sum = chunk_data[1023];
}
for (int span=start_size; span>0; span>>=1){
__syncthreads();
if (tid < span){
int from = gap*(2*tid+1)-1;
int to = gap*(2*tid+2)-1;
chunk_data[to] += chunk_data[from];
}
gap = gap * 2;
}
__syncthreads();
// out[start+(2*tid)] = chunk_data[2*tid];
// out[start+(2*tid+1)] = chunk_data[2*tid+1];
// sweep down tree
if (tid == 0){
chunk_data[1023] = 0;
}
for (int nodes=1; nodes<1024; nodes*=2){
gap >>= 1;
__syncthreads();
if (tid < nodes){
int from = gap*(2*tid+1)-1;
int to = gap*(2*tid+2)-1;
int temp = chunk_data[from];
chunk_data[from] = chunk_data[to];
chunk_data[to] += temp;
}
}
__syncthreads();
// write back to unified memory
out[start+(2*tid)] = chunk_data[2*tid];
out[start+(2*tid+1)] = chunk_data[2*tid+1];
// write to block sums
if (threadIdx.x == 0){
block_sums[blockIdx.x] += temp_block_sum + chunk_data[1023];
}
}
__global__ void apply_block_sum(int *data, int *out, int *values, int *block_sums){
int tid = threadIdx.x;
int start = 1024 * blockIdx.x;
int ind_a = start+(tid*2);
int ind_b = start+(tid*2)+1;
// if (threadIdx.x == 0) {
// if (blockIdx.x == 0) {
// val_to_add = 0;
// } else {
// val_to_add = block_sums[blockIdx.x - 1];
// }
// }
// __syncthreads();
int val_to_add = block_sums[blockIdx.x];
out[ind_a] = data[ind_a] + val_to_add;
out[ind_b] = data[ind_b] + val_to_add;
}
//__global__ void down_sweep(int *data,int *output, int *values){
// int
//}
int * serial_implementation(int * data, int vals) {
int * output = (int *)malloc(sizeof(int) * vals);
output[0] = 0;
for (int i = 1; i < vals; i++) {
output[i] = output[i-1] + data[i-1];
}
return output;
}
int main(int argc, char ** argv) {
assert(argc == 2);
int values = atoi(argv[1]); // Values is guaranteed to be no more than 10000000
int zeros;
if (values % 1024 == 0){
zeros = 0;
} else{
zeros = 1024 - (values % 1024);
}
int * data = (int *)malloc(sizeof(int) * (values+zeros));
// Generate "random" vector
std::mt19937 gen(13); // Keep constant to maintain determinism between runs
std::uniform_int_distribution<> dist(0, 50);
for (int i = 0; i < values; i++) {
data[i] = dist(gen);
}
for (int i=1; i<=zeros; i++){
data[values + i] = 0;
}
int z_values = values + zeros;
cudaStream_t stream;
cudaEvent_t begin, end;
cudaStreamCreate(&stream);
cudaEventCreate(&begin);
cudaEventCreate(&end);
int * h_output = (int *)malloc(sizeof(int) * (values+zeros)); // THIS VARIABLE SHOULD HOLD THE TOTAL COUNT BY THE END
// PERFORM NECESSARY VARIABLE DECLARATIONS HERE
int blocks = z_values/1024;
if (blocks % 1024 == 0){
zeros = 0;
} else {
zeros = 1024 - (blocks % 1024);
}
int blocks_padded = blocks + zeros;
int *data_p, *values_p, *intermediate, *num_blocks, *dummy, *block_sums, *block_sums_scanned, *bb_sums, *bb_sums_scanned, *bb_len, *blocks_intermediate;
// int * block_sums = (int *)malloc(sizeof(int) * blocks_padded);
// int * block_sums_scanned = (int *)malloc(sizeof(int) * blocks_padded);
cudaMallocManaged(&values_p, sizeof(int));
cudaMallocManaged(&num_blocks, sizeof(int));
cudaMallocManaged(&data_p, z_values * sizeof(int));
cudaMallocManaged(&intermediate, z_values * sizeof(int));
cudaMallocManaged(&h_output, z_values * sizeof(int));
cudaMallocManaged(&block_sums, blocks_padded * sizeof(int));
cudaMallocManaged(&blocks_intermediate, blocks_padded * sizeof(int));
cudaMallocManaged(&block_sums_scanned, blocks_padded * sizeof(int));
cudaMallocManaged(&dummy, blocks_padded/1024 * sizeof(int));
cudaMallocManaged(&bb_sums, 1024 * sizeof(int));
cudaMallocManaged(&bb_sums_scanned, 1024 * sizeof(int));
cudaMallocManaged(&bb_len, sizeof(int));
// PERFORM NECESSARY DATA TRANSFER HERE
*values_p = z_values;
*num_blocks = z_values/1024;
*bb_len = 1024;
for (int i=0; i<z_values; i++){
data_p[i] = data[i];
}
for (int i=0; i<blocks_padded; i++){
block_sums[i] = 0;
block_sums_scanned[i] = 0;
}
for (int i=0; i<1024; i++){
bb_sums[i] = 0;
bb_sums_scanned[i] = 0;
}
cudaEventRecord(begin, stream);
// LAUNCH KERNEL HERE
// scan data in blocks of 1024
scan_block_3 <<<z_values/1024, 512>>> (data_p, intermediate, values_p, block_sums);
cudaDeviceSynchronize();
// scan block sums array
scan_block_3 <<<blocks_padded/1024, 512>>> (block_sums, block_sums_scanned, num_blocks, bb_sums);
cudaDeviceSynchronize();
// scan block sums again
scan_block_3 <<<1, 512>>> (bb_sums, bb_sums_scanned, bb_len, dummy);
cudaDeviceSynchronize();
// apply inner blocks
apply_block_sum <<<blocks_padded/1024, 512>>> (block_sums_scanned, blocks_intermediate, bb_len, bb_sums_scanned);
cudaDeviceSynchronize();
cudaEventRecord(end, stream);
// apply block sums to intermediate
apply_block_sum <<<z_values/1024, 512>>> (intermediate, h_output, values_p, blocks_intermediate);
cudaDeviceSynchronize();
cudaEventRecord(end, stream);
/*
PERFORM NECESSARY DATA TRANSFER HERE
*/
cudaStreamSynchronize(stream);
float ms;
cudaEventElapsedTime(&ms, begin, end);
printf("Elapsed time: %f ms\n", ms);
//DEALLOCATE RESOURCES HERE
cudaFree(data_p);
cudaFree(values_p);
cudaFree(intermediate);
cudaFree(block_sums);
cudaFree(block_sums_scanned);
cudaFree(dummy);
// cudaFree(h_output);
// for (int i=0; i<values; i++){
// printf("val: %i\n", h_output[i]);
// }
int * reference_output = serial_implementation(data, values);
for (int i = 0; i < values; i++) {
if (reference_output[i] != h_output[i]) {
printf("ERROR: %d != %d at index %d\n", reference_output[i], h_output[i], i);
abort();
}
}
cudaEventDestroy(begin);
cudaEventDestroy(end);
cudaStreamDestroy(stream);
free(data);
free(reference_output);
// free(h_output);
cudaFree(h_output);
return 0;
}
|
10,210 | #include <iostream>
#define BLOCK_SIZE 512
#define CHECK(call) \
{ \
const cudaError_t error = call; \
if (error != cudaSuccess) { \
fprintf(stderr, "Error: %s:%d, ", __FILE__, __LINE__); \
fprintf(stderr, "code: %d, reason: %s\n", error, \
cudaGetErrorString(error)); \
exit(1); \
} \
}
using namespace std;
__global__ void getMin(float *input, size_t len, float *output_val,
size_t *output_idx) {
__shared__ float smem_val[BLOCK_SIZE * 2];
__shared__ size_t smem_idx[BLOCK_SIZE * 2];
int tx = threadIdx.x;
size_t i = tx + blockIdx.x * BLOCK_SIZE * 2;
if (i < len) {
smem_val[tx] = input[i];
smem_idx[tx] = i;
} else {
smem_val[tx] = INFINITY;
// Don't care about smem_idx;
}
if (i + BLOCK_SIZE < len) {
smem_val[tx + BLOCK_SIZE] = input[i + BLOCK_SIZE];
smem_idx[tx + BLOCK_SIZE] = i + BLOCK_SIZE;
} else {
smem_val[tx + BLOCK_SIZE] = INFINITY;
// Don't care about smem_idx;
}
for (int stride = BLOCK_SIZE; stride >= 1; stride /= 2) {
__syncthreads();
if (tx < stride) {
if (smem_val[tx + stride] < smem_val[tx]) {
smem_val[tx] = smem_val[tx + stride];
smem_idx[tx] = smem_idx[tx + stride];
}
}
}
if (tx == 0) {
output_val[blockIdx.x] = smem_val[0];
output_idx[blockIdx.x] = smem_idx[0];
}
}
int main(int argc, char *argv[]) {
if (argc < 2 || argc > 2) {
cout << "Usage: " << argv[0] << " size\n";
return -6;
}
const size_t len = 1L << (atoi(argv[1]));
float *h_a = (float *)malloc(len * sizeof(float));
if (h_a == nullptr) {
cout << "Cannot allocate memory\n";
exit(-6);
}
srand(0);
clock_t begin = clock();
for (size_t i = 0; i < len; ++i) {
h_a[i] = rand() / (float)RAND_MAX;
}
cout << "Elapsed time: " << double(clock() - begin) / CLOCKS_PER_SEC * 1000
<< " ms\n";
begin = clock();
size_t len_out = ceil((float)len / (BLOCK_SIZE << 1));
float *h_val = (float *)malloc(sizeof(float) * len_out);
size_t *h_idx = (size_t *)malloc(sizeof(size_t) * len_out);
float *d_a;
float *d_val;
size_t *d_idx;
CHECK(cudaMalloc((void **)&d_a, sizeof(float) * len));
CHECK(cudaMalloc((void **)&d_val, sizeof(float) * len_out));
CHECK(cudaMalloc((void **)&d_idx, sizeof(size_t) * len_out));
CHECK(cudaMemcpy(d_a, h_a, sizeof(float) * len, cudaMemcpyHostToDevice));
getMin<<<len_out, BLOCK_SIZE>>>(d_a, len, d_val, d_idx);
CHECK(cudaMemcpy(h_val, d_val, sizeof(float) * len_out,
cudaMemcpyDeviceToHost));
CHECK(cudaMemcpy(h_idx, d_idx, sizeof(size_t) * len_out,
cudaMemcpyDeviceToHost));
CHECK(cudaDeviceSynchronize());
float val = h_val[0];
size_t idx = h_idx[0];
for (size_t i = 0; i < len_out; ++i) {
if (h_val[i] < val) {
val = h_val[i];
idx = h_idx[i];
}
}
cout << "Elapsed time: " << double(clock() - begin) / CLOCKS_PER_SEC * 1000
<< " ms\n";
cout << "Number of elements: " << len << ", min val: " << val
<< ", min idx: " << idx << "\n";
// Free device
CHECK(cudaFree(d_a));
CHECK(cudaFree(d_val));
CHECK(cudaFree(d_idx));
// Free host
free(h_a);
free(h_val);
free(h_idx);
return 0;
}
|
10,211 | #include "cuda.h"
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <cstdio>
__global__ void kernelFunc(float* dst, const float* src) {
//dst -> global
float p = src[threadIdx.x]; // p goes in a register
float heap[10]; // global -> local ; thread
__shared__ float partial_sum[1024];//shared memory
} |
10,212 | /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Title :- Google Page Rank using Power method Cuda
Authors :- Rushitkumar Jasani (2018201034)
:- Priyendu Mori (2018201103)
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include <bits/stdc++.h>
#include <cuda.h>
using namespace std;
#define numberOfVertex 1000
const int V = numberOfVertex;
const int X = 32;
float graph[V][V]; // to store graph
float *output1 = NULL;
float *d_Sum_Of_Degree = NULL;
float *d_PR = NULL;
float *d_prev = NULL;
float *d_out = NULL;
float *d_Graph = NULL;
fstream inp("input.txt",ios::in);
fstream out("Output_para.txt",ios::out);
void build_matrix(float graph[V][V])
{
int source;
int dest;
while(!inp.eof()) // taking input from file
{
inp>> source >> dest;
graph[source - 1][dest - 1] = 1;
}
}
void transpose(float graph[V][V])
{
float temp;
for (int i = 0; i < V; i++)
{
for (int j = 0; j <= i; j++)
{
temp = graph[i][j];
graph[i][j] = graph[j][i];
graph[j][i] = temp;
}
}
}
float norm(float vect[V]) // find norm
{
float norm1 = 0.0;
for(int i=0;i<V;i++)
norm1 += vect[i];
return norm1;
}
__global__ void calculateSumOfOutDegree(float * sumOfOutDegree, float* Graph)
{
int i = blockDim.x * blockIdx.x + threadIdx.x;
int s;
if (i < numberOfVertex )
{
// printf("THIS IS INSIDE i : %d\n", i);
// sumOfOutDegree[i] = 0;
s = 0;
for (int j = 0; j < numberOfVertex ; ++j)
{
// sumOfOutDegree[i] += *(Graph +i*numberOfVertex +j);
// printf(" - %d - ", *(Graph + i*numberOfVertex + j));
s += *(Graph + i*numberOfVertex + j);
// sumOfOutDegree[i] += Graph[i][j];
}
// printf("this is s : %d\n",s);
for(int j=0;j<numberOfVertex;j++)
{
if(s!= 0)
*(Graph +i*numberOfVertex + j) /= s;
else // if node has no outlink.
*(Graph +i*numberOfVertex + j) = (1.0/(float)numberOfVertex);
}
}
}
__global__ void multi(float *vec, float *mat, float *out, const int V) // parallel matrix multiplication
{
int tid=threadIdx.x+(blockIdx.x*blockDim.x);
float sum=0;
if(tid<numberOfVertex)
{
for(int i=0; i<numberOfVertex; i++)
sum += vec[i]*mat[(tid*numberOfVertex)+i];
out[tid]=sum;
}
}
__global__ void compute_delta(float *vec, float *prev_vec, float norm)
{
int tid=threadIdx.x+(blockIdx.x*blockDim.x);
if(tid<numberOfVertex)
{
prev_vec[tid] -= (vec[tid]/norm);
}
}
__global__ void assign_prev(float *vec, float *prev_vec)
{
int tid=threadIdx.x+(blockIdx.x*blockDim.x);
if(tid<numberOfVertex)
{
prev_vec[tid] = vec[tid];
}
}
void power(float graph[V][V])
{
float vect[V];
float *output = (float*)malloc(sizeof(float)*V);
float pre[V];
for(int i=0;i<V;i++) // generating initial vector
{
vect[i] = (1.0/(float)V);
//vect[i] = 0.85;
pre[i] = vect[i];
}
float norm1 = norm(vect); // normalize the initial vector
for(int i=0;i<V;i++)
vect[i]/=norm1;
cudaError_t err = cudaSuccess;
err = cudaMemcpy(d_Graph, graph, numberOfVertex *V*sizeof(float), cudaMemcpyHostToDevice); // transfer graph to GPU
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy graph from host to device (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
err = cudaMemcpy(d_PR, vect, V*sizeof(float), cudaMemcpyHostToDevice); // transfer vector to GPU
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy vector from host to device (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
int count = 1000;
output1 = (float*)malloc(sizeof(float)*V);
output = (float*)malloc(sizeof(float)*V);
while(count--) // if power method don't converge
{
multi<<<V/X + 1,X>>>(d_PR, d_Graph, d_out, V);
cudaMemcpy(output, d_out, sizeof(float)*V, cudaMemcpyDeviceToHost); //transfer multiplied vector to CPU
float norm1 = norm(output); // normalize the output vector
cudaMemcpy(d_prev, pre, sizeof(float)*V, cudaMemcpyHostToDevice);
compute_delta<<< V/X + 1, X >>>(d_out, d_prev, norm1);
cudaMemcpy(pre, d_prev, sizeof(float)*V, cudaMemcpyDeviceToHost);
if(norm(pre) < 0.000000001)
{
norm1 = norm(output);
for(int i=0;i<V;i++)
output1[i] = output[i]/norm1;
break;
}
else
{
assign_prev<<< V/X + 1, X >>>(d_out, d_prev);
cudaMemcpy(pre, d_prev, sizeof(float)*V, cudaMemcpyDeviceToHost);
}
}
norm1 = norm(output);
for(int i=0;i<V;i++)
output1[i] = output[i]/norm1;
return;
}
void display_rank()
{
pair<float,int> P;
priority_queue< pair<float,int> > pq;
for(int i=0;i<V;i++)
{
P = make_pair(output1[i],i);
pq.push(P);
}
int i = 1;
while(!pq.empty())
{
P = pq.top();
printf("\nRank[%d] :%d", i, P.second + 1);
out<<"\nRank[" << i << "] :" << P.second + 1;
pq.pop();
i++;
}
}
int main(int argc,char* argv[])
{
cudaError_t err = cudaSuccess;
size_t size = numberOfVertex * sizeof(float); //size of vectors or matrices
cudaMalloc((void **)&d_Sum_Of_Degree, size);
cudaMalloc((void**)&d_PR,size);
cudaMalloc((void**)&d_out,size);
cudaMalloc((void**)&d_prev,size);
cudaMalloc((void **)&d_Graph, size * numberOfVertex );
if(d_Sum_Of_Degree == NULL || d_PR == NULL || d_Graph == NULL)
{
cout << "Failed to allocate memory on the device"<<endl;
}
build_matrix(graph); // populate graphs and process it
cudaMemcpy(d_Graph, graph, size * numberOfVertex, cudaMemcpyHostToDevice);
calculateSumOfOutDegree<<< V/X + 1,X >>>(d_Sum_Of_Degree, d_Graph);
cudaDeviceSynchronize();
cudaMemcpy(graph, d_Graph, size * numberOfVertex, cudaMemcpyDeviceToHost);
transpose(graph); // transposing to make it in correct form
clock_t start,end;
start = clock();
power(graph); // Parallel Power method
end = clock();
display_rank();
printf("Time taken :%f\n",float(end - start));
cudaFree(d_Sum_Of_Degree);
cudaFree(d_PR);
cudaFree(d_out);
cudaFree(d_Graph);
return 0;
}
|
10,213 | #include "includes.h"
__global__ void matrix_mult_kernel_tiled(int *d_m, int *d_n, int *d_p, int m, int n, int k) {
/*
* [m][k] @ [k][n] = [m][n]
*/
__shared__ int ds_m[TILE_WIDTH][TILE_WIDTH]; // ds: device shared memory
__shared__ int ds_n[TILE_WIDTH][TILE_WIDTH];
int tx = threadIdx.x;
int ty = threadIdx.y;
int bx = blockIdx.x;
int by = blockIdx.y;
int row = by * TILE_WIDTH + ty;
int col = bx * TILE_WIDTH + tx;
int pvalue = 0;
for (int i = 0; i < ceil(k / (float)TILE_WIDTH); ++i) {
// thread collaborative loading into shared memory
if (row < m && (i * TILE_WIDTH + tx) < k)
ds_m[ty][tx] = d_m[row * k + i * TILE_WIDTH + tx]; // coalesced
else
ds_m[ty][tx] = 0;
if (col < n && (i * TILE_WIDTH + ty) < k)
ds_n[ty][tx] = d_n[(i * TILE_WIDTH + ty) * n + col]; // coalesced
else
ds_n[ty][tx] = 0;
__syncthreads();
for (int j = 0; j < TILE_WIDTH; j++)
pvalue += ds_m[ty][j] * ds_n[j][tx];
__syncthreads();
}
if (row < m && col < n)
d_p[row * n + col] = pvalue;
} |
10,214 | #include "includes.h"
__global__ void histo_MonoBlock( unsigned char *buffer,long size,unsigned int *histo ) {
__shared__ unsigned int temp[256];
temp[threadIdx.x] = 0;
__syncthreads();
int i = threadIdx.x , offset = blockDim.x;
while (i < size) {
atomicAdd( &temp[buffer[i]], 1);
i += offset;
}
__syncthreads();
atomicAdd( &(histo[threadIdx.x]), temp[threadIdx.x] );
} |
10,215 | #include "includes.h"
__global__ void reciprocalKernel(float *data, unsigned vectorSize) {
unsigned idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < vectorSize)
data[idx] = 1.0 / data[idx];
} |
10,216 | #include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
#include <math.h>
#include <chrono>
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);
}
}
#define BLOCKSIZE 32
__global__ void dgemm(double* A, double* B, double* C, int N)
{
size_t myRow = blockIdx.y*blockDim.y+threadIdx.y;
size_t myCol = blockIdx.x*blockDim.x+threadIdx.x;
if (myRow < N && myCol < N)
for (size_t i = 0; i < N; i++)
C[myRow * N + myCol] += A[myRow * N + i] * B[i * N + myCol];
}
int main(int argc, char** argv)
{
double *A, *B, *C;
double *dA, *dB, *dC;
size_t N = 2048;
A = (double*) malloc (sizeof(double)*N*N);
B = (double*) malloc (sizeof(double)*N*N);
C = (double*) malloc (sizeof(double)*N*N);
for (size_t i = 0; i < N; i++)
for (size_t j = 0; j < N; j++)
{
A[i*N + j] = sin(i);
B[i*N + j] = cos(j);
}
cudaMalloc(&dA, sizeof(double)*N*N); checkCUDAError("Error allocating dA");
cudaMalloc(&dB, sizeof(double)*N*N); checkCUDAError("Error allocating dB");
cudaMalloc(&dC, sizeof(double)*N*N); checkCUDAError("Error allocating dC");
cudaMemcpy(dA, A, sizeof(double)*N*N, cudaMemcpyHostToDevice); checkCUDAError("Error copying A");
cudaMemcpy(dB, B, sizeof(double)*N*N, cudaMemcpyHostToDevice); checkCUDAError("Error copying B");
auto startTime = std::chrono::system_clock::now();
dim3 threadsPerBlock(BLOCKSIZE, BLOCKSIZE);
dim3 blocksPerGrid(N/BLOCKSIZE, N/BLOCKSIZE);
dgemm<<<blocksPerGrid,threadsPerBlock>>>(dA, dB, dC, N); checkCUDAError("Failed Kernel Launch");
cudaMemcpy(C, dC, sizeof(double)*N*N, cudaMemcpyDeviceToHost);
cudaDeviceSynchronize();
auto endTime = std::chrono::system_clock::now();
double checkSum = 0.0;
for (size_t i = 0; i < N; i++)
for (size_t j = 0; j < N; j++)
checkSum += C[i*N + j];
printf("[GPU] Checksum: %f - Elapsed Time: %fs\n", checkSum, std::chrono::duration<double>(endTime-startTime).count());
return 0;
}
|
10,217 | #include <cuda.h>
#include <stdio.h>
__global__ void printk(int *counter) {
*counter <<= 1;
printf("\t%d\n", *counter);
}
int main() {
int hcounter = 1, *counter;
cudaMalloc(&counter, sizeof(int));
do {
printf("%d\n", hcounter);
cudaMemcpy(counter, &hcounter, sizeof(int), cudaMemcpyHostToDevice);
printk <<<1, 1>>>(counter);
cudaMemcpy(&hcounter, counter, sizeof(int), cudaMemcpyDeviceToHost);
hcounter <<= 1;
} while (hcounter <= 100);
return 0;
}
|
10,218 | #include <assert.h>
#include <stdio.h>
__global__ void computeKernel(int n, int* arr) {
for (int i =2 + threadIdx.x + blockIdx.x * blockDim.x ; i <= n ; i += blockDim.x * gridDim.x) {
bool isPrime = true;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) {
isPrime = false;
}
}
if (isPrime) {
arr[i] = i;
} else {
arr[i] = -i;
}
}
}
__global__ void sumKernel(int n, int* arr, int* result) {
for (int i =2 + threadIdx.x + blockDim.x * blockIdx.x; i <= n; i += blockDim.x * gridDim.x) {
atomicAdd(result, arr[i]);
}
}
int main(int argc, char** argv) {
assert(argc == 2);
int n = atoll(argv[1]);
int* devArr;
cudaMalloc(&devArr, sizeof(int) * (n + 1));
computeKernel<<<16, 64>>>(n, devArr);
int* devResult;
cudaMalloc(&devResult, sizeof(int));
cudaMemset(devResult,0, sizeof(int) );
sumKernel<<<16, 64>>>(n, devArr, devResult);
int hostResult;
cudaMemcpy(&hostResult, devResult, sizeof(int), cudaMemcpyDeviceToHost);
printf("%d\n", hostResult);
cudaFree(devArr);
cudaFree(devResult);
}
|
10,219 | #include "kernels.cuh"
__global__ void find_maximum_kernel(float *array, float *max, int *mutex, int N) {
int start_i = threadIdx.x + blockIdx.x*blockDim.x;
int step = gridDim.x*blockDim.x;
__shared__ float cache[256];
float temp_max = -1.0f;
for(int i = start_i; i < N; i += step){
temp_max = fmaxf(temp_max, array[i]);
}
cache[threadIdx.x] = temp_max;
__syncthreads();
// reduction
for(int i = blockDim.x/2 ; i != 0 ; i /= 2){
if(threadIdx.x < i){
cache[threadIdx.x] = fmaxf(cache[threadIdx.x], cache[threadIdx.x + i]);
}
__syncthreads();
}
if(threadIdx.x == 0){
while(atomicCAS(mutex,0,1) != 0); //lock
*max = fmaxf(*max, cache[0]);
atomicExch(mutex, 0); //unlock
}
}
|
10,220 | #include "includes.h"
/* ==================================================================
Programmers:
Kevin Wagner
Elijah Malaby
John Casey
Omptimizing SDH histograms for input larger then global memory
==================================================================
*/
#define BOX_SIZE 23000 /* size of the data box on one dimension */
/* descriptors for single atom in the tree */
typedef struct atomdesc {
float x_pos;
float y_pos;
float z_pos;
} atom;
unsigned long long * histogram; /* list of all buckets in the histogram */
unsigned long long PDH_acnt; /* total number of data points */
int block_size; /* Number of threads per block */
int num_buckets; /* total number of buckets in the histogram */
float PDH_res; /* value of w */
atom * atom_list; /* list of all data points */
unsigned long long * histogram_GPU;
unsigned long long * temp_histogram_GPU;
atom * atom_list_GPU;
__global__ void kernelSumHistogram( unsigned long long int *InputHists, unsigned long long int *hist, int num_atoms, int num_buckets, int block_size) {
unsigned long long int tid = threadIdx.x + blockIdx.x * blockDim.x;
int h_pos = tid;
unsigned long long int NumberOfSumLoop = 0;
NumberOfSumLoop = (num_atoms)/block_size + ((num_atoms%block_size) ? 1:0);
while(h_pos < num_buckets) {
unsigned long long int tmpAns = 0;
for(int i=0;i<NumberOfSumLoop;i++){
tmpAns = tmpAns + *(InputHists+(i*num_buckets)+h_pos);
}
hist[h_pos] = tmpAns;
h_pos += blockDim.x * gridDim.x;
}
__syncthreads();
} |
10,221 | /*-------------hello.cu-------------------------------------------------------//
*
* hello
*
* Purpose: Hellow world with nvcc
*
*-----------------------------------------------------------------------------*/
#include <iostream>
using namespace std;
int main(void){
cout << "welcome to gpu computing! Woo!" << endl;
return 0;
}
|
10,222 | #include <cstdio>
#include <cstring>
#include <iostream>
enum class MaterialType { None, Lambertian, Metal };
struct vec3 {
float x;
float y;
float z;
};
struct GenericMaterial {
__device__ __host__ GenericMaterial():
matType(MaterialType::None),
numScalars(0), scalars(nullptr),
numVectors(0), vectors(nullptr) {
printf("Constructing GenericMaterial\n");
}
MaterialType matType;
int numScalars;
float *scalars;
int numVectors;
vec3 *vectors;
};
class Material {
public:
__device__ virtual bool scatter() const = 0;
};
class Lambertian: public Material {
public:
__device__ Lambertian(GenericMaterial* genMat) {
m_albedo = genMat->vectors[0];
}
__device__ virtual bool scatter() const {
printf("Lambertian albedo %f %f %f\n",
m_albedo.x, m_albedo.y, m_albedo.z);
return true;
}
const MaterialType matType = MaterialType::Lambertian;
private:
vec3 m_albedo;
};
class Metal: public Material {
public:
__device__ Metal(GenericMaterial* genMat) {
m_fuzz = genMat->scalars[0];
m_albedo = genMat->vectors[0];
}
__device__ virtual bool scatter() const {
printf("Metal albedo %f, %f %f %f\n",
m_fuzz, m_albedo.x, m_albedo.y, m_albedo.z);
return true;
}
const MaterialType matType = MaterialType::Metal;
private:
float m_fuzz;
vec3 m_albedo;
};
enum class ObjectType { None, Mesh, Sphere };
struct GenericObject {
__device__ __host__ GenericObject() :
objType(ObjectType::None),
numScalars(0), scalars(nullptr),
numVectors(0), vectors(nullptr) {}
ObjectType objType;
int numScalars;
float *scalars;
int numVectors;
vec3 *vectors;
};
class Object {
public:
__device__ virtual bool hit() const = 0;
const ObjectType objType = ObjectType::None;
protected:
Material *m_material;
};
class Mesh: public Object {
public:
const ObjectType objType = ObjectType::Mesh;
__device__ Mesh(GenericObject* genObj, Material* mat) {
m_numVertices = genObj->numVectors;
m_vertices = genObj->vectors;
m_material = mat;
}
__device__ virtual bool hit() const {
printf("hitting trianglemesh %d\n", m_numVertices);
m_material->scatter();
return true;
}
private:
int m_numVertices;
vec3 *m_vertices;
};
class Sphere: public Object {
public:
const ObjectType objType = ObjectType::Sphere;
__device__ Sphere(GenericObject* genObj, Material* mat) {
m_radius = genObj->scalars[0];
m_x = genObj->scalars[1];
m_material = mat;
}
__device__ virtual bool hit() const {
printf("hitting sphere %f, %f\n", m_radius, m_x);
m_material->scatter();
return true;
}
private:
float m_radius;
float m_x;
};
class ObjectList: public Object {
public:
__device__ ObjectList() :
objects(nullptr), num_objects(0) {}
__device__ ObjectList(Object** objects, int num_objects) :
objects(objects), num_objects(num_objects) {}
__device__ virtual bool hit() const {
for (int i = 0; i < num_objects; i++) {
objects[i]->hit();
}
return true;
}
Object **objects;
int num_objects;
};
__global__ void create_world(GenericObject* genObjList,
GenericMaterial* genMatList,
int numObjects,
Object** objectList,
Object** world)
{
printf("numObjects = %d\n", numObjects);
for (int objIdx = 0; objIdx < numObjects; objIdx++) {
Material *mat = nullptr;
GenericMaterial* genMat = &(genMatList[objIdx]);
if (genMat->matType == MaterialType::Lambertian) {
printf("Lambertian\n");
mat = new Lambertian(genMat);
}
else if (genMat->matType == MaterialType::Metal) {
printf("Metal\n");
mat = new Metal(genMat);
}
GenericObject* genObj = &(genObjList[objIdx]);
if (genObj->objType == ObjectType::Sphere) {
printf("Sphere %f %f\n", genObj->scalars[0], genObj->scalars[1]);
objectList[objIdx] = new Sphere(genObj, mat);
}
else if (genObj->objType == ObjectType::Mesh) {
printf("Mesh %d\n", genObj->numVectors);
objectList[objIdx] = new Mesh(genObj, mat);
}
}
*world = new ObjectList(objectList, numObjects);
}
__global__ void render_world(Object** world, int numObjects)
{
(*world)->hit();
}
void setupScene(GenericObject** genObjList,
GenericMaterial** genMatList, int& o_numObjects)
{
std::cout << "Setting up scene ..." << std::endl;
int numObjects = 2;
*genObjList = new GenericObject[numObjects];
*genMatList = new GenericMaterial[numObjects];
// Sphere
int numScalars = 2;
(*genObjList)[0].objType = ObjectType::Sphere;
(*genObjList)[0].numScalars = numScalars;
(*genObjList)[0].scalars = new float[numScalars];
(*genObjList)[0].scalars[0] = 1.0f;
(*genObjList)[0].scalars[1] = 0.5f;
(*genMatList)[0].matType = MaterialType::Lambertian;
(*genMatList)[0].numVectors = 1;
(*genMatList)[0].vectors = new vec3;
(*genMatList)[0].vectors[0] = {0.25f, 0.35f, 0.45f};
// Mesh
int numVectors = 3;
(*genObjList)[1].objType = ObjectType::Mesh;
(*genObjList)[1].numVectors = numVectors;
(*genObjList)[1].vectors = new vec3[numVectors];
(*genObjList)[1].vectors[0] = {0.0f, 0.0f, 0.0f};
(*genObjList)[1].vectors[1] = {1.0f, 0.0f, 0.0f};
(*genObjList)[1].vectors[2] = {0.0f, 1.0f, 0.0f};
(*genMatList)[1].matType = MaterialType::Metal;
(*genMatList)[1].numVectors = 1;
(*genMatList)[1].vectors = new vec3;
(*genMatList)[1].vectors[0] = {0.55f, 0.65f, 0.75f};
(*genMatList)[1].numScalars = 1;
(*genMatList)[1].scalars = new float;
(*genMatList)[1].scalars[0] = 0.95f;
o_numObjects = numObjects;
std::cout << "Setting up scene done." << std::endl;
}
int main()
{
GenericObject *genObjList;
GenericMaterial *genMatList;
int numObjects;
setupScene(&genObjList, &genMatList, numObjects);
// copy genObjList to device
// helpful: https://stackoverflow.com/questions/19404965/how-to-use-cudamalloc-cudamemcpy-for-a-pointer-to-a-structure-containing-point
GenericObject *h_genObjList = new GenericObject[numObjects];
std::memcpy(h_genObjList, genObjList, numObjects*sizeof(GenericObject));
for (int objIdx = 0; objIdx < numObjects; objIdx++) {
if (h_genObjList[objIdx].numScalars > 0) {
cudaMalloc((void**)&(h_genObjList[objIdx].scalars),
h_genObjList[objIdx].numScalars*sizeof(float));
cudaMemcpy(h_genObjList[objIdx].scalars, genObjList[objIdx].scalars,
h_genObjList[objIdx].numScalars*sizeof(float), cudaMemcpyHostToDevice);
}
if (h_genObjList[objIdx].numVectors > 0) {
cudaMalloc((void**)&(h_genObjList[objIdx].vectors),
h_genObjList[objIdx].numVectors*sizeof(vec3));
cudaMemcpy(h_genObjList[objIdx].vectors, genObjList[objIdx].vectors,
h_genObjList[objIdx].numVectors*sizeof(vec3), cudaMemcpyHostToDevice);
}
}
GenericObject *d_genObjList;
cudaMalloc((void**)&d_genObjList, numObjects*sizeof(GenericObject));
cudaMemcpy(d_genObjList, h_genObjList, numObjects*sizeof(GenericObject), cudaMemcpyHostToDevice);
//~copy genObjList to device
// copy genMatList to device
// helpful: https://stackoverflow.com/questions/19404965/how-to-use-cudamalloc-cudamemcpy-for-a-pointer-to-a-structure-containing-point
GenericMaterial *h_genMatList = new GenericMaterial[numObjects];
std::memcpy(h_genMatList, genMatList, numObjects*sizeof(GenericMaterial));
for (int objIdx = 0; objIdx < numObjects; objIdx++) {
if (h_genMatList[objIdx].numScalars > 0) {
cudaMalloc((void**)&(h_genMatList[objIdx].scalars),
h_genMatList[objIdx].numScalars*sizeof(float));
cudaMemcpy(h_genMatList[objIdx].scalars, genMatList[objIdx].scalars,
h_genMatList[objIdx].numScalars*sizeof(float), cudaMemcpyHostToDevice);
}
if (h_genMatList[objIdx].numVectors > 0) {
cudaMalloc((void**)&(h_genMatList[objIdx].vectors),
h_genMatList[objIdx].numVectors*sizeof(vec3));
cudaMemcpy(h_genMatList[objIdx].vectors, genMatList[objIdx].vectors,
h_genMatList[objIdx].numVectors*sizeof(vec3), cudaMemcpyHostToDevice);
}
}
GenericMaterial *d_genMatList;
cudaMalloc((void**)&d_genMatList, numObjects*sizeof(GenericMaterial));
cudaMemcpy(d_genMatList, h_genMatList, numObjects*sizeof(GenericMaterial), cudaMemcpyHostToDevice);
//~copy genMatList to device
Object **d_list;
cudaMalloc((void**)&d_list, numObjects*sizeof(Object*));
Object **d_world;
cudaMalloc((void**)&d_world, sizeof(Object*));
create_world<<<1,1>>>(d_genObjList, d_genMatList, numObjects, d_list, d_world);
cudaDeviceSynchronize();
std::cout << cudaGetErrorString(cudaGetLastError()) << std::endl;
render_world<<<1,1>>>(d_world, numObjects);
cudaDeviceSynchronize();
std::cout << cudaGetErrorString(cudaGetLastError()) << std::endl;
return 0;
}
|
10,223 | #include <iostream>
__global__ void kernel(void)
{
//code
}
int main(void)
{
//code
kernel<<<1,1>>>();
printf("Hello World\n");
return (0);
}
|
10,224 | #include "includes.h"
__global__ void findCentroidsAtomicFreeReduce(int afLocal, int* responses, int nPixels, int* cluster, int* centroidMass, unsigned int* centroidCount)
{
int const af_id = blockIdx.x;
int const cluster_id = blockIdx.y;
int const filter_id = threadIdx.x;
int local_mass = 0;
int local_count = 0;
if (af_id == 0)
{
int idx0 = filter_id*64 + cluster_id;
for (int i=0; i<gridDim.x; i++)
{
int idxother = i * gridDim.y*blockDim.x + idx0;
local_mass += centroidMass[idxother];
local_count += centroidCount[idxother];
}
centroidMass[idx0] = local_mass;
centroidCount[idx0] = local_count;
}
} |
10,225 | #include <stdio.h>
__global__ void add(int *res, int a, int b) {
*res = a + b;
}
int main(void) {
int res;
int *device_res = NULL;
cudaError_t mres;
// Allocate memory on the device
// You cannot dereference this in host code!
mres = cudaMalloc(&device_res, sizeof(int));
if (mres != cudaSuccess) {
printf("Malloc failed\n");
return -1;
}
// Do computation
add<<<1,1>>>(device_res, 2, 7);
// Copy result back to host
mres = cudaMemcpy(&res, device_res, sizeof(int), cudaMemcpyDeviceToHost);
if (mres != cudaSuccess) {
printf("Memcpy failed\n");
return -1;
}
// Now free the memory we allocated on the device
mres = cudaFree(device_res);
if (mres != cudaSuccess) {
printf("Free failed\n");
return -1;
}
printf("2 + 7 = %d\n", res);
return 0;
}
|
10,226 | #include <stdio.h>
#define N 64
#define TPB 256
__global__ void print_kernel()
{
printf("Hello world! My threadID is %d\n", threadIdx.x);
}
int main()
{
print_kernel <<<1, TPB >>> ();
cudaDeviceSynchronize();
return 0;
} |
10,227 | #include "includes.h"
__global__ void average_snips(const double *Params, const int *iC, const int *call, const int *id, const float *uproj, const float *cmax, float *WU){
//Nfilt blocks
//Thread grid = (NrankPC, NchanNear)
//This implementation does not work correctly for real data!
//Since this_chan is function of the spike -- spikes assigned to a given template
//will have max channels that span a 2-3 channel range -- different (tidx, tidy)
//pairs can wind up trying to add to the same element of dWU, resulting in
//collisions and incorrect results. Use the single-threaded version
//average_snips_v2 instead. Speed hit is only ~ 5-6 seconds out of 360 sec for a
//typical 2 hour Neuropixels 1.0 dataset.
int my_chan, this_chan, tidx, tidy, bid, ind, Nspikes, NrankPC, NchanNear, Nchan;
float xsum = 0.0f;
Nspikes = (int) Params[0];
NrankPC = (int) Params[1];
Nchan = (int) Params[7];
NchanNear = (int) Params[6];
tidx = threadIdx.x;
tidy = threadIdx.y;
bid = blockIdx.x;
for(ind=0; ind<Nspikes;ind++) {
if (id[ind]==bid){
my_chan = call[ind];
this_chan = iC[tidy + NchanNear * my_chan];
xsum = uproj[tidx + NrankPC*tidy + NrankPC*NchanNear * ind];
WU[tidx + NrankPC*this_chan + NrankPC*Nchan * bid] += xsum;
}
}
} |
10,228 | #include "includes.h"
/************************* CudaMat ******************************************
* Copyright (C) 2008-2009 by Rainer Heintzmann *
* heintzmann@gmail.com *
* *
* 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; Version 2 of the License. *
* *
* 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., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************
* Compile with:
* Windows:
system('"c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin\vcvars32.bat"')
system('nvcc -c cudaArith.cu -ccbin "c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin')
Window 64 bit:
system('nvcc -c cudaArith.cu -ccbin "c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin" -I"c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include" ')
Linux:
* File sudo vi /usr/local/cuda/bin/nvcc.profile
* needs the flag -fPIC in the include line
system('nvcc -c cudaArith.cu -v -I/usr/local/cuda/include/')
*/
// To suppress the unused variable argument for ARM targets
#pragma diag_suppress 177
#ifndef NAN // should be part of math.h
#define NAN (0.0/0.0)
#endif
#define ACCU_ARRTYPE double // Type of the tempory arrays for reduce operations
#define IMUL(a, b) __mul24(a, b)
//#define BLOCKSIZE 512
//#define BLOCKSIZE 512
// below is blocksize for temporary array for reduce operations. Has to be a power of 2 in size
#ifndef CUIMAGE_REDUCE_THREADS // this can be defined at compile time via the flag NVCCFLAG='-D CUIMAGE_REDUCE_THREADS=512'
#define CUIMAGE_REDUCE_THREADS 512
#endif
// (prop.maxThreadsPerBlock)
// #define CUIMAGE_REDUCE_THREADS 512
// #define CUIMAGE_REDUCE_THREADS 128
//#define CUIMAGE_REDUCE_BLOCKS 64
#define NBLOCKS(N,blockSize) (N/blockSize+(N%blockSize==0?0:1))
#define NBLOCKSL(N,blockSize) 1
// min((N/blockSize+(N%blockSize==0?0:1)),prop.maxGridSize[0])
__global__ void set_carr(float br, float bi, float * c, size_t N)
{
size_t idx=((blockIdx.y*gridDim.x+blockIdx.x)*blockDim.x+threadIdx.x);
if(idx>=N) return;
size_t idc=idx*2;
c[idc]=br;c[idc+1]=bi;
} |
10,229 | //kernel fior tiled multiplication
__global__ void
MatrixMulKernel(float* P, const float* M, const float* N, int matrix_size){
//thread index
// int threadX = threadIdx.x;
int threadY = threadIdx.y;
//block index
// int blockX = blockIdx.x;
int blockY = blockIdx.y;
//FIND position in gloval matrix
//int column_number = blockDim.x*blockX + threadX;
int row_number = blockDim.y*blockY + threadY;
double P_temp = 0;
int k;
for( k = 0;k< matrix_size; k++){
double M_element = M[matrix_size*row_number + k];
double N_element = N[k];
P_temp += M_element*N_element;
}
P[k] = (float)P_temp;
}
|
10,230 | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
__global__ void kempty()
{
return;
}
void measure_empty()
{
struct timeval t1, t2;
// Start empty kernel
dim3 Db = dim3(512);
dim3 Dg = dim3(16,16,16);
fprintf (stderr, "Running (%d x %d x %d) blocks of %d empty threads...", Dg.x, Dg.y, Dg.z, Db.x);
gettimeofday(&t1, NULL);
kempty <<<Dg, Db>>>();
cudaThreadSynchronize();
gettimeofday(&t2, NULL);
fprintf (stderr, "done\n");
printf ("Running (%d x %d x %d) blocks of %d empty threads: %.3f ms\n", Dg.x, Dg.y, Dg.z, Db.x,
(t2.tv_sec - t1.tv_sec)*1000.0 + (t2.tv_usec - t1.tv_usec)*0.001);
printf ("\n");
}
|
10,231 | #include "includes.h"
__global__ void sumArraysOnGPU(double *A, double *B, double *C, const int N)
{
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < N) C[i] = A[i] + B[i] + 7*A[i] + 4*B[i]/123.1 - B[i]*A[i] + B[i]*B[i] - 9*B[i]*B[i]*B[i]/0.4 + A[i]/0.2 + B[i]*B[i];
} |
10,232 | #include <stdio.h>
#include <math.h>
template <int TILE_WIDTH> __global__ void multi(float *a, float *b, float *c, int width) {
__shared__ float s_a[TILE_WIDTH][TILE_WIDTH];
__shared__ float s_b[TILE_WIDTH][TILE_WIDTH];
int row = blockIdx.y * blockDim.y + threadIdx.y;
int col = blockIdx.x * blockDim.x + threadIdx.x;
float result = 0;
for (int p = 0; p < width/TILE_WIDTH; p++) {
s_a[threadIdx.y][threadIdx.x] = a[row*width + (p*TILE_WIDTH + threadIdx.x)];
s_b[threadIdx.y][threadIdx.x] = b[(p*TILE_WIDTH + threadIdx.y)*width + col];
__syncthreads();
for (int i = 0; i < TILE_WIDTH; i++) {
result += s_a[threadIdx.y][i] * s_b[i][threadIdx.x];
}
__syncthreads();
}
c[row * width + col] = result;
}
int main(int arg0, char **arg1) {
cudaThreadSynchronize();
int width = atoi(arg1[1]);
int THREADS_PER_BLOCK = 64;
if(arg0 == 3) THREADS_PER_BLOCK = atoi(arg1[2]);
int sqrtThreads = sqrt(THREADS_PER_BLOCK);
int nBlocks = width/sqrtThreads;
if (width % sqrtThreads != 0) {
nBlocks++;
}
dim3 grid(nBlocks, nBlocks, 1);
dim3 block(sqrtThreads, sqrtThreads, 1);
float *a_h;
float *b_h;
float *c_h;
float *d_h;
float *a_d;
float *b_d;
float *c_d;
int size;
cudaEvent_t start;
cudaEvent_t stop;
float elapsed1;
size = width * width * sizeof(float);
a_h = (float*) malloc(size);
b_h = (float*) malloc(size);
c_h = (float*) malloc(size);
d_h = (float*) malloc(size);
for (int i = 0; i < width; i++) {
for (int j = 0; j < width; j++) {
a_h[i * width + j] = i;
b_h[i * width + j] = i;
}
}
cudaMalloc((void**)&a_d, size);
cudaMalloc((void**)&b_d, size);
cudaMalloc((void**)&c_d, size);
cudaMemcpy(a_d, a_h, size, cudaMemcpyHostToDevice);
cudaMemcpy(b_d, b_h, size, cudaMemcpyHostToDevice);
cudaMemcpy(c_d, c_h, size, cudaMemcpyHostToDevice);
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start, 0);
if(sqrtThreads == 2) multi<2><<<grid, block>>>(a_d, b_d, c_d, width);
if(sqrtThreads == 4) multi<4><<<grid, block>>>(a_d, b_d, c_d, width);
if(sqrtThreads == 8) multi<8><<<grid, block>>>(a_d, b_d, c_d, width);
if(sqrtThreads == 16) multi<16><<<grid, block>>>(a_d, b_d, c_d, width);
if(sqrtThreads == 32) multi<32><<<grid, block>>>(a_d, b_d, c_d, width);
cudaDeviceSynchronize();
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
cudaEventElapsedTime(&elapsed1, start, stop);
printf("%f\n", elapsed1/1000);
cudaMemcpy(c_h, c_d, size, cudaMemcpyDeviceToHost);
free(a_h);
free(b_h);
free(c_h);
free(d_h);
cudaFree(a_d);
cudaFree(b_d);
cudaFree(c_d);
cudaEventDestroy(start);
cudaEventDestroy(stop);
return 0;
}
|
10,233 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#define IMG_SIZE 256
#define BLOCK_SIZE 1
#define N (IMG_SIZE * IMG_SIZE)
__device__ int iterate_pixel(float x, float y, float c_re, float c_im) {
int c=0;
float z_re=x;
float z_im=y;
while (c<255) {
float re2=z_re*z_re;
float im2=z_im*z_im;
if ((re2+im2) > 4) break;
z_im=2*z_re*z_im + c_im;
z_re=re2-im2 + c_re;
c++;
}
return c;
}
__global__ void calc_fractal(int width, int height, float c_re, float c_im, unsigned char* dest) {
int x = (threadIdx.x + blockIdx.x * blockDim.x) % IMG_SIZE;
int y = (threadIdx.x + blockIdx.x * blockDim.x) / width;
float f_x = (float)(x*0.8) / (float)(width)-0.8;
float f_y = (float)(y*0.8) / (float)(height)-0.8;
dest[threadIdx.x + blockIdx.x * blockDim.x]=iterate_pixel(f_x,f_y, c_re, c_im);
}
// Write a width by height 8-bit color image into File "filename"
void write_ppm(unsigned char* data,unsigned int width,unsigned int height,char* filename)
{
if (data == NULL) {
printf("Provide a valid data pointer!\n");
return;
}
if (filename == NULL) {
printf("Provide a valid filename!\n");
return;
}
if ( (width>4096) || (height>4096)) {
printf("Only pictures upto 4096x4096 are supported!\n");
return;
}
FILE *f=fopen(filename,"wb");
if (f == NULL)
{
printf("Opening File %s failed!\n",filename);
return;
}
if (fprintf(f,"P6 %i %i 255\n",width,height) <= 0) {
printf("Writing to file failed!\n");
return;
};
int i;
for (i=0;i<height;i++) {
unsigned char buffer[4096*3];
int j;
for (j=0;j<width;j++) {
int v=data[i*width+j];
int s;
s= v << 0;
s=s > 255? 255 : s;
buffer[j*3+0]=s;
s= v << 1;
s=s > 255? 255 : s;
buffer[j*3+1]=s;
s= v << 2;
s=s > 255? 255 : s;
buffer[j*3+2]=s;
}
if (fwrite(buffer,width*3,1,f) != 1) {
printf("Writing of line %i to file failed!\n",i);
return;
}
}
fclose(f);
}
int main(void) {
unsigned char *img, *dev_img;
int size = IMG_SIZE * IMG_SIZE * sizeof(char);
img = (unsigned char *) malloc(IMG_SIZE*IMG_SIZE);
cudaMalloc((void**)&dev_img, size);
assert(img != NULL);
assert(dev_img != NULL);
calc_fractal<<< N/BLOCK_SIZE, BLOCK_SIZE >>> (256, 256, 0.28, 0.008, dev_img);
cudaMemcpy(img, dev_img, size, cudaMemcpyDeviceToHost);
write_ppm(img,IMG_SIZE,IMG_SIZE,"julia.ppm");
free(img);
cudaFree(dev_img);
return 0;
}
|
10,234 | /*
This script is a mockup of the fuctionality to be parallelized in the Monte Carlo
Simulation. It calculates "energy" among pairs of "atoms" in a system, and compares
serial and parallel performance.
The command line arguments are as follows:
first argument (optional) - integer representing number of atoms
- defaults to 100
- input -1 to run benchmarking suite for
10000 <= N <= 40000 and specified thread
block size
second argument (optional) - integer <= 1024 representing thread block size
- input -1 to run benchmarking suite for
64 <= BS <= 1024 and specified N value
For example, -1 512 will run all N with block size = 512
-1 or -1 -1 will run all N for all block sizes
20000 -1 will run N = 20000 for all block sizes
Each simulation adds a line into RunLog.log with data about the run.
*/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
//Given two indices in an array (representing atoms),
//calculate their product (potential energy),
//and store in energies array.
//Parallel
__global__ void calcEnergyParallel(int *atoms, int numAtoms, int *energies, int numEnergies)
{
int atom1 = blockIdx.x, atom2 = blockIdx.y * blockDim.x + threadIdx.x,
energyIdx;
if (atom2 < numAtoms && atom2 > atom1)
{
energyIdx = gridDim.x * atom1 + atom2 - (blockIdx.x + 1) * (blockIdx.x + 2) / 2;
energies[energyIdx] = atoms[atom1] * atoms[atom2];
}
}
//Given two indices in an array (representing atoms),
//calculate their product (potential energy),
//and store in energies array.
//Serial
void calcEnergySerial(int *atoms, int numAtoms, int *energies, int numEnergies)
{
int i, j, k;
for (i = 0; i < numAtoms; i++)
{
for (j = 0; j < numAtoms; j++)
{
if (j > i)
{
k = numAtoms * i + j - (i + 1) * (i + 2) / 2;
energies[k] = atoms[i] * atoms[j];
}
}
}
}
void run(int N, int BLOCK_SIZE)
{
printf("Called with %u and %u\n", N, BLOCK_SIZE);
clock_t S_TIME, P_TIME;
int *atomsHost, *atomsDevice, *energiesHost, *energiesDevice, gridYDim = 1, blockXDim = N;
unsigned long int totalEnergy, atomsSize, energiesSize;
atomsSize = N * sizeof(int);
energiesSize = sizeof(int) * N * (N - 1) / 2;
atomsHost = (int*) malloc(atomsSize);
energiesHost = (int*) malloc(energiesSize);
int i;
for (i = 0; i < N; i++)
{
atomsHost[i] = i;
}
for (i = 0; i < energiesSize / sizeof(int); i++)
{
energiesHost[i] = 0;
}
//Serial Run
S_TIME = clock();
calcEnergySerial(atomsHost, N, energiesHost, energiesSize / sizeof(int));
totalEnergy = 0;
for (i = 0; i < energiesSize / sizeof(int); i++)
{
totalEnergy += energiesHost[i];
}
printf("Serial: Total Energy for %u atoms is %u Pseudo-Joules.\n", N, totalEnergy);
S_TIME = clock() - S_TIME;
//Reset energiesHost
for (i = 0; i < energiesSize / sizeof(int); i++)
{
energiesHost[i] = 0;
}
//Parallel Run
P_TIME = clock();
if (N > BLOCK_SIZE)
{
gridYDim = N / BLOCK_SIZE + 1;
blockXDim = BLOCK_SIZE;
}
dim3 gridDim(N, gridYDim, 1);
dim3 blockDim(blockXDim, 1, 1);
cudaMalloc(&atomsDevice, atomsSize);
cudaMalloc(&energiesDevice, energiesSize);
cudaMemcpy(atomsDevice, atomsHost, atomsSize, cudaMemcpyHostToDevice);
cudaMemcpy(energiesDevice, energiesHost, energiesSize, cudaMemcpyHostToDevice);
//N blocks of N threads (every atom pair)
calcEnergyParallel<<<gridDim, blockDim>>>(atomsDevice, N, energiesDevice, energiesSize / sizeof(int));
cudaMemcpy(energiesHost, energiesDevice, energiesSize, cudaMemcpyDeviceToHost);
totalEnergy = 0;
for (i = 0; i < energiesSize / sizeof(int); i++)
{
totalEnergy += energiesHost[i];
}
printf("Parallel: Total Energy for %u atoms is %u Pseudo-Joules.\n", N, totalEnergy);
P_TIME = clock() - P_TIME;
printf("The parallel code runs %fx as fast as the serial version.\n", (float) S_TIME / (float) P_TIME);
free(atomsHost);
free(energiesHost);
cudaFree(atomsDevice);
cudaFree(energiesDevice);
FILE *log = fopen("RunLog.log", "a");
fprintf(log, "%u\t\t%u\t\t%.2f\t\t%.2f\t\t%.2f\n", N, BLOCK_SIZE, (float) S_TIME / CLOCKS_PER_SEC, (float) P_TIME / CLOCKS_PER_SEC, (float) S_TIME / (float) P_TIME);
fclose(log);
}
int main(int argc, char *argv[])
{
int BLOCK_SIZE = 128, N = 100;
if (argc > 1 && atoi(argv[1]) != -1)
{
N = atoi(argv[1]);
if (argc == 3 && atoi(argv[2]) == -1)
{
for (BLOCK_SIZE = 64; BLOCK_SIZE <= 1024; BLOCK_SIZE <<= 1)
{
run(N, BLOCK_SIZE);
}
}
else if (argc == 3)
{
BLOCK_SIZE = atoi(argv[2]);
run(N, BLOCK_SIZE);
}
}
else if (argc > 1 && atoi(argv[1]) == -1)
{
for (N = 10000; N <= 40000; N += 10000)
{
if (argc == 2 && atoi(argv[2]) > 0)
{
run (N, atoi(argv[2]));
}
else
{
for (BLOCK_SIZE = 64; BLOCK_SIZE <= 1024; BLOCK_SIZE <<= 1)
{
run(N, BLOCK_SIZE);
}
}
}
}
else
{
run(N, BLOCK_SIZE);
}
if (N <= 0 || BLOCK_SIZE <= 0)
{
printf("Invalid Parameters for Number of Atoms and GPU Block Size (#threads).\n");
return 1;
}
return 0;
} |
10,235 | #include <cuda.h>
#include <stdio.h>
#include <time.h>
//> Kernel definition
__global__ void gpuVecadd(int* v1, int* v2, int* ans, int n){
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < n)
{
ans[i] = v1[i] + v2[i];
}
}
int main(int argc, char const *argv[])
{
int N = 0;
double timeGPU;
int *h_v1, *h_v2, *h_ans, *d_v1, *d_v2, *d_ans;
if (argc != 2)
{
N = 10;
}else{
N = atoi(argv[1]);
}
size_t bytes = N * sizeof(int);
h_v1 = (int *)malloc(bytes);
h_v2 = (int *)malloc(bytes);
h_ans = (int *)malloc(bytes);
for (int i = 0; i < N; i++)
{
h_v1[i] = i;
h_v2[i] = i;
h_ans[i] = 0;
}
if (cudaSuccess != cudaMalloc((void **) &d_v1, bytes)) printf("Error allocating mem. for d_v1\n");
if (cudaSuccess != cudaMalloc((void **) &d_v2, bytes)) printf("Error allocating mem. for d_v2\n");
if (cudaSuccess != cudaMalloc((void **) &d_ans, bytes)) printf("Error allocating mem. for d_ans\n");
if (cudaSuccess != cudaMemcpy(d_v1, h_v1, bytes, cudaMemcpyHostToDevice)) printf("Error copying data for d_v1\n");
if (cudaSuccess != cudaMemcpy(d_v2, h_v2, bytes, cudaMemcpyHostToDevice)) printf("Error copying data for d_v2\n");
dim3 blockDim(32,32);
dim3 gridDim((int)ceil((float)N/blockDim.x), (int)ceil((float)N/blockDim.y));
clock_t startGPU = clock();
gpuVecadd<<<gridDim, blockDim>>>(d_v1, d_v2, d_ans, N);
if (cudaSuccess != cudaGetLastError()) printf("Error calling kernel\n");
if (cudaSuccess != cudaMemcpy(h_ans, d_ans, bytes, cudaMemcpyDeviceToHost)) printf("Error copying data for d_ans\n");
timeGPU = ((double)(clock() - startGPU))/CLOCKS_PER_SEC;
printf("Size v1 = %d, v2 = %d\n", N, N);
printf("GPU time = %.6f seconds\n",timeGPU);
if (N <= 10){
for(int m = 0; m < N; m++){
printf("%d,",h_ans[m]);
}
printf("\n");
}
free(h_v1); free(h_v2); free(h_ans);
cudaFree(d_v1); cudaFree(d_v2); cudaFree(h_ans);
return 0;
} |
10,236 | //verion 1
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <math.h>
#include <fstream>
#include <cuda.h>
#include <device_functions.h>
using namespace std;
#define SIZE 10240
#define MAXVN 10
__global__ void addKernel(double *c, const double *a, const double *b)
{
int i = threadIdx.x;
c[i] = exp(a[i]+b[i]);
}
__global__ void simulatedAnnealingKernel(int *route,
double * costs,
const int solutionLen,
const int *demands,
const double * distances,
const int nodeNum,
const int capacities,
const int vNum,
const int *randInt,
const double *randDouble,
const double tempParam,
const double cr)
{
int depot = threadIdx.x;
int *bestSolution = route + (depot)*solutionLen;
__shared__ int solutionArray[SIZE];
//ÿ̷߳3*solutonLen*4 Byte СĹڴ
//ڴ
int *solution = &solutionArray[threadIdx.x*(solutionLen*2+7*MAXVN)]; //solutionLen
int *curSolution = (int *)&solution[solutionLen]; //solutionLen
double *dice =(double*)&curSolution[solutionLen];
double *dis = (double*)&dice[1];
double *newDis = (double*)&dis[1];
int *cusIndex = (int*)&newDis[1];
int *range = (int*)&cusIndex[1];
int *v = (int*)&range[1];
int *improvedTryCounter = (int*)&v[1];
int *demandCounter=(int*)&improvedTryCounter[MAXVN]; //4
int *routeStart=(int*)&demandCounter[MAXVN]; //6
double *acc = (double*)&routeStart[MAXVN+1]; //5
int *r1=v;
int *r2=range;
int *inter =cusIndex;
//Ĵ
int maxDemandIndex = 0;
double demandSum = 0;
double minCost = 100000;
int insertPoint = 0;
int cus=0;
double cost=0;
int pre=0;
int cur=0;
int i=0;
int maxDemand=0;
int nextRand = 0;
int strategy = 0;
double temp = tempParam;//cr = 0.001;//tempPara;
//
*dis = 0;
int len = 1;
for(int i =1; bestSolution[i]!=0; i++){
pre = bestSolution[i-1];
cur = bestSolution[i];
*dis += distances[(pre-1)*nodeNum+cur-1];
len ++;
}
for(int i =0; i< len; i++){
solution[i] = bestSolution[i];
curSolution[i] = bestSolution[i];
}
//Ƿ
maxDemandIndex = 0;
demandSum = 0;
*v = 0;
demandCounter[*v] = 0;
routeStart[*v] = 0;
for(i = 1;i<len; i++){
if (solution[i] == depot+1){
if( demandCounter[*v] > demandCounter[maxDemandIndex])
maxDemandIndex = *v;
(*v)++;
demandCounter[*v] = 0;
routeStart[*v] = i;
}
else{
demandCounter[*v]+= demands[solution[i]-1];
demandSum += demands[solution[i]-1];
}
}
//ж½ǷԼ
for(i=0; i<vNum; i++){
if(demandCounter[i] > capacities){
*dis += capacities;
}
}
costs[depot] = *dis;
improvedTryCounter[0] =1;
improvedTryCounter[1]=1;
while(temp > 0.01){
//ѡ
*dice =randDouble[(nextRand+threadIdx.x*20)%1000];
nextRand =(nextRand+1)%1000;
if(*dice <= 0.1+0.8*(improvedTryCounter[0]/(double)(improvedTryCounter[0]+improvedTryCounter[1]))){
//ѡ1
strategy = 0;
*r1 = 1+randInt[(nextRand+threadIdx.x*20)%1000]%(len-2);
nextRand = (++nextRand)%1000;
*r2 = 1+randInt[(nextRand+threadIdx.x*20)%1000]%(len-2);
nextRand = (++nextRand)%1000;
//swap *r1,*r2 in solution
*inter = solution[*r1];
solution[*r1] = solution[*r2];
solution[*r2] = *inter;
}
else{
//ѡ2
//ͳƸĸأݳĸص
strategy = 1;
maxDemandIndex = 0;
demandSum = 0;
*v = 0;
demandCounter[*v] = 0;
routeStart[*v] = 0;
for(i = 1;i<len; i++){
if (solution[i] == depot+1){
if( demandCounter[*v] > demandCounter[maxDemandIndex])
maxDemandIndex = *v;
(*v)++;
demandCounter[*v] = 0;
routeStart[*v] = i;
}
else{
demandCounter[*v]+= demands[solution[i]-1];
demandSum += demands[solution[i]-1];
}
}
acc[0] = demandCounter[0]/(demandSum+0.1);
for(i = 1; i< vNum; i++){
acc[i] = acc[i-1]+demandCounter[i]/(demandSum+0.1);
}
acc[i-1] = 1;
*dice =randDouble[(nextRand+threadIdx.x*20)%1000];
nextRand = (++nextRand)%1000;
*v = 0;
while(*dice>acc[*v]) (*v)++; //ҵӦijΪv
//vгȡһͻȻ뵽ijʵ·λ ͻλӦrouteStart[*v]routeStart[v+1]֮
*range = routeStart[*v+1]-routeStart[*v]-1;
if(*range ==0)
continue;
*cusIndex = routeStart[*v]+1+randInt[(nextRand+threadIdx.x*20)%1000]%*range;
nextRand = (++nextRand)%1000;
//ѡؽСij
maxDemand = demandCounter[maxDemandIndex];
acc[0] = (maxDemand - demandCounter[0])/(vNum*maxDemand - demandSum+0.1);
for(i =1; i< vNum; i++){
acc[i] = acc[i-1]+(maxDemand - demandCounter[i])/(vNum*maxDemand - demandSum+0.1);
}
acc[i-1] = 1;
//demandCounter
demandCounter[*v] -= demands[solution[*cusIndex]-1];
*dice =randDouble[(nextRand+threadIdx.x*20)%1000];
nextRand = (++nextRand)%1000;
*v = 0;
while(*dice>acc[*v]) (*v)++; //ҵӦijΪ*v ䷶ΧΪrouteStart[*v]routeStart[*v+1]
//demandCounter
demandCounter[*v] += demands[solution[*cusIndex]-1];
minCost = 100000;
insertPoint = 0;
cus = solution[*cusIndex];
cost = 0;
//*cusIndexӦĿͻ뵽*vӦ·кʵλ
for(i = routeStart[*v]; i<routeStart[*v+1]; i++){
cost = distances[(cus-1)*nodeNum+solution[i]-1]+
distances[(cus-1)*nodeNum+solution[i+1]-1]-
distances[(solution[i]-1)*nodeNum+solution[i+1]-1];
if(cost < minCost){
minCost =cost;
insertPoint = i;
}
}
//cus*cusIndexλò뵽insertPointλ
if( *cusIndex <insertPoint){
for(int i = *cusIndex; i <insertPoint; i++){
solution[i] = solution[i+1];
}
solution[insertPoint] = cus;
}else{
for(int i = *cusIndex; i >insertPoint+1; i--){
solution[i] = solution[i-1];
}
solution[insertPoint+1] = cus;
}
}
//½ܾ
*newDis = 0;
for(i =1; i<len-1;i++){
pre = solution[i];
cur = solution[i+1];
*newDis += distances[(pre-1)*nodeNum+cur-1];
}
//ж½ǷԼ
for(i=0; i<vNum; i++){
if(demandCounter[i] > capacities){
*newDis += capacities;
}
}
//½ȵǰţ滻
if(*newDis < *dis){
for(i = 0;i< len; i++){
curSolution[i] = solution[i];
}
*dis = *newDis;
improvedTryCounter[strategy] ++;
//Žţ滻Ž
if( *newDis < costs[depot]){
for(i =0; i< len; i++){
bestSolution[i] = solution[i];
}
costs[depot] = *newDis;
}
}else{
//Ը exp((dis - newDis)/temp)滻
*dice =randDouble[(nextRand+threadIdx.x*20)%1000];
nextRand = (++nextRand)%1000;
if(*dice < exp((*dis - *newDis)/temp)){
for(i = 0;i< len; i++){
curSolution[i] = solution[i];
}
*dis = *newDis;
}else{
//½⣬ԭ
for(i = 0;i< len; i++){
solution[i] = curSolution[i];
}
}
}
temp *=1 - cr;
__syncthreads();
}
}
int main(){
const int nodeNum = 52;
const int depotNum = 2;
const int vehicleNum = 6;
const int solutionLen = nodeNum - depotNum + vehicleNum + 1;
int r[depotNum*solutionLen] = {0};
int demand[nodeNum] = {0};
double dis[nodeNum*nodeNum]={0};
double randDouble[1000] = {0};
int randInt[1000] ={0};
int capacities = 5000;
int vNum =6;
ifstream routeStream("routes.txt");
ifstream distanceStream("distances.txt");
ifstream demandStream("demands.txt");
ifstream rdStream("randDouble.txt");
ifstream riStream("randInt.txt");
for(int i=0; i<depotNum; i++){
for(int j =0; j< solutionLen; j++){
routeStream>>r[i*solutionLen+j];
}
}
for(int i=0; i<nodeNum; i++){
demandStream>>demand[i];
for(int j = 0; j< nodeNum; j++){
distanceStream>>dis[i*nodeNum + j];
}
}
for(int i=0; i<1000; i++){
rdStream>>randDouble[i];
riStream>>randInt[i];
}
routeStream.close();
distanceStream.close();
demandStream.close();
riStream.close();
rdStream.close();
double costs[depotNum]={0};
cudaError e;
int* d_r;
e = cudaMalloc((void**)&d_r,sizeof(int)*depotNum*solutionLen);
e = cudaMemcpy(d_r,r,sizeof(int)*depotNum*solutionLen,cudaMemcpyHostToDevice);
double* d_costs;
e = cudaMalloc((void**)&d_costs,sizeof(double)*depotNum);
int *d_demand;
e = cudaMalloc((void**)&d_demand,sizeof(int)*nodeNum);
e = cudaMemcpy(d_demand,demand,sizeof(int)*nodeNum,cudaMemcpyHostToDevice);
double *d_dis;
e = cudaMalloc((void**)&d_dis,sizeof(double)*nodeNum*nodeNum);
e = cudaMemcpy(d_dis,dis,sizeof(double)*nodeNum*nodeNum,cudaMemcpyHostToDevice);
int *d_randInt;
e = cudaMalloc((void**)&d_randInt,sizeof(int)*1000);
e = cudaMemcpy(d_randInt,randInt,sizeof(int)*1000,cudaMemcpyHostToDevice);
double *d_randDouble;
e = cudaMalloc((void**)&d_randDouble,sizeof(double)*1000);
e = cudaMemcpy(d_randDouble,randDouble,sizeof(double)*1000,cudaMemcpyHostToDevice);
simulatedAnnealingKernel<<<1,depotNum>>>(d_r,d_costs,solutionLen,d_demand,d_dis,nodeNum,capacities,vNum,d_randInt,d_randDouble,100000,0.001);
e = cudaMemcpy(r,d_r,sizeof(int)*depotNum*solutionLen,cudaMemcpyDeviceToHost);
e = cudaMemcpy(costs,d_costs,sizeof(double)*depotNum,cudaMemcpyDeviceToHost);
cudaFree(d_r);
cudaFree(d_costs);
cudaFree(d_demand);
cudaFree(d_dis);
cudaFree(d_randDouble);
cudaFree(d_randInt);
return 0;
}
|
10,237 | #include "includes.h"
__global__ void CalcMass(double *Mass_d, double *GlobalMass_d, double *Rho_d, double A, double *Altitudeh_d, double *lonlat_d, double *areasT, int num, bool DeepModel) {
int id = blockIdx.x * blockDim.x + threadIdx.x;
int nv = gridDim.y;
int lev = blockIdx.y;
if (id < num) {
//calculate control volume
double zup, zlow, Vol;
zup = Altitudeh_d[lev + 1] + A;
zlow = Altitudeh_d[lev] + A;
if (DeepModel) {
Vol = areasT[id] / pow(A, 2) * (pow(zup, 3) - pow(zlow, 3)) / 3;
}
else {
Vol = areasT[id] * (zup - zlow);
}
//mass in control volume = density*volume
Mass_d[id * nv + lev] = Rho_d[id * nv + lev] * Vol;
}
} |
10,238 | extern "C" {
__device__ inline int threadIdx_x() { return threadIdx.x; }
__device__ inline int threadIdx_y() { return threadIdx.y; }
__device__ inline int threadIdx_z() { return threadIdx.z; }
__device__ inline int blockIdx_x() { return blockIdx.x; }
__device__ inline int blockIdx_y() { return blockIdx.y; }
__device__ inline int blockIdx_z() { return blockIdx.z; }
__device__ inline int blockDim_x() { return blockDim.x; }
__device__ inline int blockDim_y() { return blockDim.y; }
__device__ inline int blockDim_z() { return blockDim.z; }
__device__ inline int gridDim_x() { return gridDim.x; }
__device__ inline int gridDim_y() { return gridDim.y; }
__device__ inline int gridDim_z() { return gridDim.z; }
__global__ void lambda_453087(int, float*, int, float*);
__global__ void lambda_452720(int, float*, int, float*);
__global__ void lambda_452341(int, float*);
__global__ __launch_bounds__ (32 * 4 * 1) void lambda_453087(int _453090_681165, float* _453091_681166, int _453092_681167, float* _453093_681168) {
int threadIdx_x_681174;
int pthreadIdx_x_681174;
int blockDim_x_681180;
int pblockDim_x_681180;
int blockIdx_x_681186;
int pblockIdx_x_681186;
int _681192;
int p_681192;
int _681198;
int p_681198;
int _681204;
int p_681204;
int _681207;
int p_681207;
float converge_703771;
float pconverge_703771;
float converge_681222;
float pconverge_681222;
int converge_703765;
int pconverge_703765;
int converge_681231;
int pconverge_681231;
int converge_703760;
int pconverge_703760;
int converge_681237;
int pconverge_681237;
int converge_703755;
int pconverge_703755;
int converge_681243;
int pconverge_681243;
int converge_703750;
int pconverge_703750;
int converge_681247;
int pconverge_681247;
int converge_703745;
int pconverge_703745;
int converge_681252;
int pconverge_681252;
int converge_703740;
int pconverge_703740;
int converge_681257;
int pconverge_681257;
int converge_703735;
int pconverge_703735;
int converge_681262;
int pconverge_681262;
int converge_703730;
int pconverge_703730;
int converge_681265;
int pconverge_681265;
int converge_703725;
int pconverge_703725;
int converge_681268;
int pconverge_681268;
int converge_703720;
int pconverge_703720;
int converge_681271;
int pconverge_681271;
int converge_703715;
int pconverge_703715;
int converge_681274;
int pconverge_681274;
int converge_703710;
int pconverge_703710;
int converge_681277;
int pconverge_681277;
int converge_703705;
int pconverge_703705;
int converge_681281;
int pconverge_681281;
int converge_703700;
int pconverge_703700;
int converge_681284;
int pconverge_681284;
int converge_703695;
int pconverge_703695;
int converge_681287;
int pconverge_681287;
int converge_703690;
int pconverge_703690;
int converge_681290;
int pconverge_681290;
int converge_703685;
int pconverge_703685;
int converge_681293;
int pconverge_681293;
int converge_703680;
int pconverge_703680;
int converge_681296;
int pconverge_681296;
int converge_703675;
int pconverge_703675;
int converge_681301;
int pconverge_681301;
int converge_703670;
int pconverge_703670;
int converge_681304;
int pconverge_681304;
int converge_703665;
int pconverge_703665;
int converge_681307;
int pconverge_681307;
int converge_703660;
int pconverge_703660;
int converge_681310;
int pconverge_681310;
int converge_703655;
int pconverge_703655;
int converge_681313;
int pconverge_681313;
int converge_703650;
int pconverge_703650;
int converge_681316;
int pconverge_681316;
int converge_703645;
int pconverge_703645;
int converge_681321;
int pconverge_681321;
int converge_703640;
int pconverge_703640;
int converge_681324;
int pconverge_681324;
int converge_703635;
int pconverge_703635;
int converge_681327;
int pconverge_681327;
int converge_703630;
int pconverge_703630;
int converge_681330;
int pconverge_681330;
int converge_703625;
int pconverge_703625;
int converge_681333;
int pconverge_681333;
int converge_703620;
int pconverge_703620;
int converge_681336;
int pconverge_681336;
int converge_703615;
int pconverge_703615;
int converge_681339;
int pconverge_681339;
int converge_703610;
int pconverge_703610;
int converge_681344;
int pconverge_681344;
int converge_703605;
int pconverge_703605;
int converge_681349;
int pconverge_681349;
int converge_703600;
int pconverge_703600;
int converge_681352;
int pconverge_681352;
int converge_703595;
int pconverge_703595;
int converge_681355;
int pconverge_681355;
int converge_703590;
int pconverge_703590;
int converge_681361;
int pconverge_681361;
int converge_703585;
int pconverge_703585;
int converge_681364;
int pconverge_681364;
int converge_703580;
int pconverge_703580;
int converge_681367;
int pconverge_681367;
int converge_703575;
int pconverge_703575;
int converge_681370;
int pconverge_681370;
int converge_703570;
int pconverge_703570;
int converge_681373;
int pconverge_681373;
int converge_703565;
int pconverge_703565;
int converge_681376;
int pconverge_681376;
int converge_703560;
int pconverge_703560;
int converge_681379;
int pconverge_681379;
int converge_703555;
int pconverge_703555;
int converge_681382;
int pconverge_681382;
int converge_703550;
int pconverge_703550;
int converge_681385;
int pconverge_681385;
int converge_703545;
int pconverge_703545;
int converge_681388;
int pconverge_681388;
int converge_703540;
int pconverge_703540;
int converge_681391;
int pconverge_681391;
int converge_703535;
int pconverge_703535;
int converge_681394;
int pconverge_681394;
int converge_703530;
int pconverge_703530;
int converge_681397;
int pconverge_681397;
int converge_703525;
int pconverge_703525;
int converge_681400;
int pconverge_681400;
int converge_703520;
int pconverge_703520;
int converge_681403;
int pconverge_681403;
int converge_703515;
int pconverge_703515;
int converge_681406;
int pconverge_681406;
int converge_703510;
int pconverge_703510;
int converge_681409;
int pconverge_681409;
int converge_703505;
int pconverge_703505;
int converge_681412;
int pconverge_681412;
int converge_703500;
int pconverge_703500;
int converge_681415;
int pconverge_681415;
int converge_703495;
int pconverge_703495;
int converge_681418;
int pconverge_681418;
int converge_703490;
int pconverge_703490;
int converge_681421;
int pconverge_681421;
int converge_703485;
int pconverge_703485;
int converge_681424;
int pconverge_681424;
int converge_703480;
int pconverge_703480;
int converge_681427;
int pconverge_681427;
int converge_703475;
int pconverge_703475;
int converge_681430;
int pconverge_681430;
int converge_703470;
int pconverge_703470;
int converge_681433;
int pconverge_681433;
int converge_703465;
int pconverge_703465;
int converge_681438;
int pconverge_681438;
int converge_703460;
int pconverge_703460;
int converge_681441;
int pconverge_681441;
int converge_703455;
int pconverge_703455;
int converge_681444;
int pconverge_681444;
int converge_703450;
int pconverge_703450;
int converge_681447;
int pconverge_681447;
int converge_703445;
int pconverge_703445;
int converge_681450;
int pconverge_681450;
int converge_703440;
int pconverge_703440;
int converge_681453;
int pconverge_681453;
int converge_703435;
int pconverge_703435;
int converge_681458;
int pconverge_681458;
int converge_703430;
int pconverge_703430;
int converge_681461;
int pconverge_681461;
int converge_703425;
int pconverge_703425;
int converge_681464;
int pconverge_681464;
int converge_703420;
int pconverge_703420;
int converge_681467;
int pconverge_681467;
int converge_703415;
int pconverge_703415;
int converge_681470;
int pconverge_681470;
int converge_703410;
int pconverge_703410;
int converge_681473;
int pconverge_681473;
int converge_703405;
int pconverge_703405;
int converge_681476;
int pconverge_681476;
int converge_703400;
int pconverge_703400;
int converge_681479;
int pconverge_681479;
int converge_703395;
int pconverge_703395;
int converge_681482;
int pconverge_681482;
int converge_703390;
int pconverge_703390;
int converge_681485;
int pconverge_681485;
int converge_703385;
int pconverge_703385;
int converge_681488;
int pconverge_681488;
int converge_703380;
int pconverge_703380;
int converge_681491;
int pconverge_681491;
int converge_703375;
int pconverge_703375;
int converge_681494;
int pconverge_681494;
int converge_703370;
int pconverge_703370;
int converge_681497;
int pconverge_681497;
int converge_703365;
int pconverge_703365;
int converge_681500;
int pconverge_681500;
int converge_703360;
int pconverge_703360;
int converge_681503;
int pconverge_681503;
int converge_703355;
int pconverge_703355;
int converge_681506;
int pconverge_681506;
int converge_703350;
int pconverge_703350;
int converge_681509;
int pconverge_681509;
int converge_703345;
int pconverge_703345;
int converge_681514;
int pconverge_681514;
int converge_703340;
int pconverge_703340;
int converge_681517;
int pconverge_681517;
int converge_703335;
int pconverge_703335;
int converge_681520;
int pconverge_681520;
int converge_703330;
int pconverge_703330;
int converge_681523;
int pconverge_681523;
int converge_703325;
int pconverge_703325;
int converge_681526;
int pconverge_681526;
int converge_703320;
int pconverge_703320;
int converge_681529;
int pconverge_681529;
int converge_703315;
int pconverge_703315;
int converge_681532;
int pconverge_681532;
int converge_703310;
int pconverge_703310;
int converge_681535;
int pconverge_681535;
int converge_703305;
int pconverge_703305;
int converge_681538;
int pconverge_681538;
int converge_703300;
int pconverge_703300;
int converge_681541;
int pconverge_681541;
int converge_703295;
int pconverge_703295;
int converge_681544;
int pconverge_681544;
int converge_703290;
int pconverge_703290;
int converge_681547;
int pconverge_681547;
int converge_703285;
int pconverge_703285;
int converge_681550;
int pconverge_681550;
int converge_703280;
int pconverge_703280;
int converge_681553;
int pconverge_681553;
int converge_703275;
int pconverge_703275;
int converge_681556;
int pconverge_681556;
int converge_703270;
int pconverge_703270;
int converge_681559;
int pconverge_681559;
int converge_703265;
int pconverge_703265;
int converge_681562;
int pconverge_681562;
int converge_703260;
int pconverge_703260;
int converge_681565;
int pconverge_681565;
int converge_703255;
int pconverge_703255;
int converge_681568;
int pconverge_681568;
int converge_703250;
int pconverge_703250;
int converge_681571;
int pconverge_681571;
int converge_703245;
int pconverge_703245;
int converge_681574;
int pconverge_681574;
int converge_703240;
int pconverge_703240;
int converge_681577;
int pconverge_681577;
int converge_703235;
int pconverge_703235;
int converge_681580;
int pconverge_681580;
int converge_703230;
int pconverge_703230;
int converge_681583;
int pconverge_681583;
int converge_703225;
int pconverge_703225;
int converge_681586;
int pconverge_681586;
int converge_703220;
int pconverge_703220;
int converge_681589;
int pconverge_681589;
int converge_703215;
int pconverge_703215;
int converge_681592;
int pconverge_681592;
int converge_703210;
int pconverge_703210;
int converge_681595;
int pconverge_681595;
int converge_703205;
int pconverge_703205;
int converge_681598;
int pconverge_681598;
int converge_703200;
int pconverge_703200;
int converge_681601;
int pconverge_681601;
int converge_703195;
int pconverge_703195;
int converge_681604;
int pconverge_681604;
int converge_703190;
int pconverge_703190;
int converge_681607;
int pconverge_681607;
int converge_703185;
int pconverge_703185;
int converge_681610;
int pconverge_681610;
int converge_703180;
int pconverge_703180;
int converge_681613;
int pconverge_681613;
int converge_703175;
int pconverge_703175;
int converge_681616;
int pconverge_681616;
int converge_703170;
int pconverge_703170;
int converge_681619;
int pconverge_681619;
int converge_703165;
int pconverge_703165;
int converge_681622;
int pconverge_681622;
int converge_703160;
int pconverge_703160;
int converge_681625;
int pconverge_681625;
int converge_703155;
int pconverge_703155;
int converge_681628;
int pconverge_681628;
int converge_703150;
int pconverge_703150;
int converge_681631;
int pconverge_681631;
int converge_703145;
int pconverge_703145;
int converge_681634;
int pconverge_681634;
int converge_703140;
int pconverge_703140;
int converge_681637;
int pconverge_681637;
int converge_703135;
int pconverge_703135;
int converge_681640;
int pconverge_681640;
int converge_703130;
int pconverge_703130;
int converge_681643;
int pconverge_681643;
int converge_703125;
int pconverge_703125;
int converge_681646;
int pconverge_681646;
int converge_703120;
int pconverge_703120;
int converge_681649;
int pconverge_681649;
int converge_703115;
int pconverge_703115;
int converge_681652;
int pconverge_681652;
int converge_703110;
int pconverge_703110;
int converge_681655;
int pconverge_681655;
int converge_703105;
int pconverge_703105;
int converge_681658;
int pconverge_681658;
int converge_703100;
int pconverge_703100;
int converge_681661;
int pconverge_681661;
int converge_703095;
int pconverge_703095;
int converge_681664;
int pconverge_681664;
int converge_703090;
int pconverge_703090;
int converge_681667;
int pconverge_681667;
int converge_703085;
int pconverge_703085;
int converge_681670;
int pconverge_681670;
int converge_703080;
int pconverge_703080;
int converge_681673;
int pconverge_681673;
int converge_703075;
int pconverge_703075;
int converge_681676;
int pconverge_681676;
int converge_703070;
int pconverge_703070;
int converge_681679;
int pconverge_681679;
int converge_703065;
int pconverge_703065;
int converge_681682;
int pconverge_681682;
int converge_703060;
int pconverge_703060;
int converge_681685;
int pconverge_681685;
int converge_703055;
int pconverge_703055;
int converge_681688;
int pconverge_681688;
int converge_703050;
int pconverge_703050;
int converge_681691;
int pconverge_681691;
int converge_703045;
int pconverge_703045;
int converge_681694;
int pconverge_681694;
int converge_703040;
int pconverge_703040;
int converge_681697;
int pconverge_681697;
int converge_703035;
int pconverge_703035;
int converge_681700;
int pconverge_681700;
int converge_703030;
int pconverge_703030;
int converge_681703;
int pconverge_681703;
int converge_703025;
int pconverge_703025;
int converge_681706;
int pconverge_681706;
int converge_703020;
int pconverge_703020;
int converge_681709;
int pconverge_681709;
int converge_703015;
int pconverge_703015;
int converge_681712;
int pconverge_681712;
int converge_703010;
int pconverge_703010;
int converge_681715;
int pconverge_681715;
int converge_703005;
int pconverge_703005;
int converge_681718;
int pconverge_681718;
int converge_703000;
int pconverge_703000;
int converge_681721;
int pconverge_681721;
int converge_702995;
int pconverge_702995;
int converge_681724;
int pconverge_681724;
int converge_702990;
int pconverge_702990;
int converge_681727;
int pconverge_681727;
int converge_702985;
int pconverge_702985;
int converge_681730;
int pconverge_681730;
int converge_702980;
int pconverge_702980;
int converge_681733;
int pconverge_681733;
int converge_702975;
int pconverge_702975;
int converge_681736;
int pconverge_681736;
int converge_702970;
int pconverge_702970;
int converge_681739;
int pconverge_681739;
int converge_702965;
int pconverge_702965;
int converge_681742;
int pconverge_681742;
int converge_702960;
int pconverge_702960;
int converge_681745;
int pconverge_681745;
int converge_702955;
int pconverge_702955;
int converge_681748;
int pconverge_681748;
int converge_702950;
int pconverge_702950;
int converge_681751;
int pconverge_681751;
int converge_702945;
int pconverge_702945;
int converge_681754;
int pconverge_681754;
int converge_702940;
int pconverge_702940;
int converge_681757;
int pconverge_681757;
int converge_702935;
int pconverge_702935;
int converge_681760;
int pconverge_681760;
int converge_702930;
int pconverge_702930;
int converge_681763;
int pconverge_681763;
int converge_702925;
int pconverge_702925;
int converge_681766;
int pconverge_681766;
int converge_702920;
int pconverge_702920;
int converge_681769;
int pconverge_681769;
int converge_702915;
int pconverge_702915;
int converge_681772;
int pconverge_681772;
int converge_702910;
int pconverge_702910;
int converge_681775;
int pconverge_681775;
int converge_702905;
int pconverge_702905;
int converge_681778;
int pconverge_681778;
int converge_702900;
int pconverge_702900;
int converge_681781;
int pconverge_681781;
int converge_702895;
int pconverge_702895;
int converge_681784;
int pconverge_681784;
int converge_702890;
int pconverge_702890;
int converge_681787;
int pconverge_681787;
int converge_702885;
int pconverge_702885;
int converge_681790;
int pconverge_681790;
int converge_702880;
int pconverge_702880;
int converge_681793;
int pconverge_681793;
int converge_702875;
int pconverge_702875;
int converge_681796;
int pconverge_681796;
int converge_702870;
int pconverge_702870;
int converge_681799;
int pconverge_681799;
int converge_702865;
int pconverge_702865;
int converge_681802;
int pconverge_681802;
int converge_702860;
int pconverge_702860;
int converge_681805;
int pconverge_681805;
int converge_702855;
int pconverge_702855;
int converge_681808;
int pconverge_681808;
int converge_702850;
int pconverge_702850;
int converge_681811;
int pconverge_681811;
int converge_702845;
int pconverge_702845;
int converge_681814;
int pconverge_681814;
int converge_702840;
int pconverge_702840;
int converge_681817;
int pconverge_681817;
int converge_702835;
int pconverge_702835;
int converge_681820;
int pconverge_681820;
int converge_702830;
int pconverge_702830;
int converge_681823;
int pconverge_681823;
int converge_702825;
int pconverge_702825;
int converge_681826;
int pconverge_681826;
int converge_702820;
int pconverge_702820;
int converge_681829;
int pconverge_681829;
int converge_702815;
int pconverge_702815;
int converge_681832;
int pconverge_681832;
int converge_702810;
int pconverge_702810;
int converge_681835;
int pconverge_681835;
int converge_702805;
int pconverge_702805;
int converge_681838;
int pconverge_681838;
int converge_702800;
int pconverge_702800;
int converge_681841;
int pconverge_681841;
int converge_702795;
int pconverge_702795;
int converge_681844;
int pconverge_681844;
int converge_702790;
int pconverge_702790;
int converge_681847;
int pconverge_681847;
int converge_702785;
int pconverge_702785;
int converge_681850;
int pconverge_681850;
int converge_702780;
int pconverge_702780;
int converge_681853;
int pconverge_681853;
int converge_702775;
int pconverge_702775;
int converge_681856;
int pconverge_681856;
int converge_702770;
int pconverge_702770;
int converge_681859;
int pconverge_681859;
int converge_702765;
int pconverge_702765;
int converge_681862;
int pconverge_681862;
int converge_702760;
int pconverge_702760;
int converge_681865;
int pconverge_681865;
int converge_702755;
int pconverge_702755;
int converge_681868;
int pconverge_681868;
int converge_702750;
int pconverge_702750;
int converge_681871;
int pconverge_681871;
int converge_702745;
int pconverge_702745;
int converge_681874;
int pconverge_681874;
int converge_702740;
int pconverge_702740;
int converge_681877;
int pconverge_681877;
int converge_702735;
int pconverge_702735;
int converge_681880;
int pconverge_681880;
int converge_702730;
int pconverge_702730;
int converge_681883;
int pconverge_681883;
int converge_702725;
int pconverge_702725;
int converge_681886;
int pconverge_681886;
int converge_702720;
int pconverge_702720;
int converge_681889;
int pconverge_681889;
int converge_702715;
int pconverge_702715;
int converge_681892;
int pconverge_681892;
int converge_702710;
int pconverge_702710;
int converge_681895;
int pconverge_681895;
int converge_702705;
int pconverge_702705;
int converge_681898;
int pconverge_681898;
int converge_702700;
int pconverge_702700;
int converge_681901;
int pconverge_681901;
int converge_702695;
int pconverge_702695;
int converge_681904;
int pconverge_681904;
int converge_702690;
int pconverge_702690;
int converge_681907;
int pconverge_681907;
int converge_702685;
int pconverge_702685;
int converge_681910;
int pconverge_681910;
int converge_702680;
int pconverge_702680;
int converge_681913;
int pconverge_681913;
int converge_702675;
int pconverge_702675;
int converge_681916;
int pconverge_681916;
int converge_702670;
int pconverge_702670;
int converge_681919;
int pconverge_681919;
int converge_702665;
int pconverge_702665;
int converge_681922;
int pconverge_681922;
int converge_702660;
int pconverge_702660;
int converge_681925;
int pconverge_681925;
int converge_702655;
int pconverge_702655;
int converge_681928;
int pconverge_681928;
int converge_702650;
int pconverge_702650;
int converge_681931;
int pconverge_681931;
int converge_702645;
int pconverge_702645;
int converge_681934;
int pconverge_681934;
int converge_702640;
int pconverge_702640;
int converge_681937;
int pconverge_681937;
int converge_702635;
int pconverge_702635;
int converge_681940;
int pconverge_681940;
int converge_702630;
int pconverge_702630;
int converge_681943;
int pconverge_681943;
int converge_702625;
int pconverge_702625;
int converge_681946;
int pconverge_681946;
int converge_702620;
int pconverge_702620;
int converge_681949;
int pconverge_681949;
int converge_702615;
int pconverge_702615;
int converge_681952;
int pconverge_681952;
int converge_702610;
int pconverge_702610;
int converge_681955;
int pconverge_681955;
int converge_702605;
int pconverge_702605;
int converge_681958;
int pconverge_681958;
int converge_702600;
int pconverge_702600;
int converge_681961;
int pconverge_681961;
int converge_702595;
int pconverge_702595;
int converge_681964;
int pconverge_681964;
int converge_702590;
int pconverge_702590;
int converge_681967;
int pconverge_681967;
int converge_702585;
int pconverge_702585;
int converge_681970;
int pconverge_681970;
int converge_702580;
int pconverge_702580;
int converge_681973;
int pconverge_681973;
int converge_702575;
int pconverge_702575;
int converge_681976;
int pconverge_681976;
int converge_702570;
int pconverge_702570;
int converge_681979;
int pconverge_681979;
float converge_702565;
float pconverge_702565;
float converge_688039;
float pconverge_688039;
int converge_702559;
int pconverge_702559;
int converge_688042;
int pconverge_688042;
int converge_702554;
int pconverge_702554;
int converge_688045;
int pconverge_688045;
int converge_702549;
int pconverge_702549;
int converge_688048;
int pconverge_688048;
int converge_702544;
int pconverge_702544;
int converge_688051;
int pconverge_688051;
int converge_702539;
int pconverge_702539;
int converge_688054;
int pconverge_688054;
int converge_702534;
int pconverge_702534;
int converge_688057;
int pconverge_688057;
int converge_702529;
int pconverge_702529;
int converge_688060;
int pconverge_688060;
int converge_702524;
int pconverge_702524;
int converge_688063;
int pconverge_688063;
int converge_702519;
int pconverge_702519;
int converge_688066;
int pconverge_688066;
int converge_702514;
int pconverge_702514;
int converge_688069;
int pconverge_688069;
int converge_702509;
int pconverge_702509;
int converge_688072;
int pconverge_688072;
int converge_702504;
int pconverge_702504;
int converge_688075;
int pconverge_688075;
int converge_702499;
int pconverge_702499;
int converge_688078;
int pconverge_688078;
int converge_702494;
int pconverge_702494;
int converge_688081;
int pconverge_688081;
int converge_702489;
int pconverge_702489;
int converge_688084;
int pconverge_688084;
int converge_702484;
int pconverge_702484;
int converge_688087;
int pconverge_688087;
int converge_702479;
int pconverge_702479;
int converge_688090;
int pconverge_688090;
int converge_702474;
int pconverge_702474;
int converge_688093;
int pconverge_688093;
int converge_702469;
int pconverge_702469;
int converge_688096;
int pconverge_688096;
int converge_702464;
int pconverge_702464;
int converge_688099;
int pconverge_688099;
int converge_702459;
int pconverge_702459;
int converge_688102;
int pconverge_688102;
int converge_702454;
int pconverge_702454;
int converge_688105;
int pconverge_688105;
int converge_702449;
int pconverge_702449;
int converge_688108;
int pconverge_688108;
int converge_702444;
int pconverge_702444;
int converge_688111;
int pconverge_688111;
int converge_702439;
int pconverge_702439;
int converge_688114;
int pconverge_688114;
int converge_702434;
int pconverge_702434;
int converge_688117;
int pconverge_688117;
int converge_702429;
int pconverge_702429;
int converge_688120;
int pconverge_688120;
int converge_702424;
int pconverge_702424;
int converge_688123;
int pconverge_688123;
int converge_702419;
int pconverge_702419;
int converge_688126;
int pconverge_688126;
int converge_702414;
int pconverge_702414;
int converge_688129;
int pconverge_688129;
int converge_702409;
int pconverge_702409;
int converge_688132;
int pconverge_688132;
int converge_702404;
int pconverge_702404;
int converge_688135;
int pconverge_688135;
int converge_702399;
int pconverge_702399;
int converge_688138;
int pconverge_688138;
int converge_702394;
int pconverge_702394;
int converge_688141;
int pconverge_688141;
int converge_702389;
int pconverge_702389;
int converge_688144;
int pconverge_688144;
int converge_702384;
int pconverge_702384;
int converge_688147;
int pconverge_688147;
int converge_702379;
int pconverge_702379;
int converge_688150;
int pconverge_688150;
int converge_702374;
int pconverge_702374;
int converge_688153;
int pconverge_688153;
int converge_702369;
int pconverge_702369;
int converge_688156;
int pconverge_688156;
int converge_702364;
int pconverge_702364;
int converge_688159;
int pconverge_688159;
int converge_702359;
int pconverge_702359;
int converge_688162;
int pconverge_688162;
int converge_702354;
int pconverge_702354;
int converge_688165;
int pconverge_688165;
int converge_702349;
int pconverge_702349;
int converge_688168;
int pconverge_688168;
int converge_702344;
int pconverge_702344;
int converge_688171;
int pconverge_688171;
int converge_702339;
int pconverge_702339;
int converge_688174;
int pconverge_688174;
int converge_702334;
int pconverge_702334;
int converge_688177;
int pconverge_688177;
int converge_702329;
int pconverge_702329;
int converge_688180;
int pconverge_688180;
int converge_702324;
int pconverge_702324;
int converge_688183;
int pconverge_688183;
int converge_702319;
int pconverge_702319;
int converge_688186;
int pconverge_688186;
int converge_702314;
int pconverge_702314;
int converge_688189;
int pconverge_688189;
int converge_702309;
int pconverge_702309;
int converge_688192;
int pconverge_688192;
int converge_702304;
int pconverge_702304;
int converge_688195;
int pconverge_688195;
int converge_702299;
int pconverge_702299;
int converge_688198;
int pconverge_688198;
int converge_702294;
int pconverge_702294;
int converge_688201;
int pconverge_688201;
int converge_702289;
int pconverge_702289;
int converge_688204;
int pconverge_688204;
int converge_702284;
int pconverge_702284;
int converge_688207;
int pconverge_688207;
int converge_702279;
int pconverge_702279;
int converge_688210;
int pconverge_688210;
int converge_702274;
int pconverge_702274;
int converge_688213;
int pconverge_688213;
int converge_702269;
int pconverge_702269;
int converge_688216;
int pconverge_688216;
int converge_702264;
int pconverge_702264;
int converge_688219;
int pconverge_688219;
int converge_702259;
int pconverge_702259;
int converge_688222;
int pconverge_688222;
int converge_702254;
int pconverge_702254;
int converge_688225;
int pconverge_688225;
int converge_702249;
int pconverge_702249;
int converge_688228;
int pconverge_688228;
int converge_702244;
int pconverge_702244;
int converge_688231;
int pconverge_688231;
int converge_702239;
int pconverge_702239;
int converge_688234;
int pconverge_688234;
int converge_702234;
int pconverge_702234;
int converge_688237;
int pconverge_688237;
int converge_702229;
int pconverge_702229;
int converge_688240;
int pconverge_688240;
int converge_702224;
int pconverge_702224;
int converge_688243;
int pconverge_688243;
int converge_702219;
int pconverge_702219;
int converge_688246;
int pconverge_688246;
int converge_702214;
int pconverge_702214;
int converge_688249;
int pconverge_688249;
int converge_702209;
int pconverge_702209;
int converge_688252;
int pconverge_688252;
int converge_702204;
int pconverge_702204;
int converge_688255;
int pconverge_688255;
int converge_702199;
int pconverge_702199;
int converge_688258;
int pconverge_688258;
int converge_702194;
int pconverge_702194;
int converge_688261;
int pconverge_688261;
int converge_702189;
int pconverge_702189;
int converge_688264;
int pconverge_688264;
int converge_702184;
int pconverge_702184;
int converge_688267;
int pconverge_688267;
int converge_702179;
int pconverge_702179;
int converge_688270;
int pconverge_688270;
int converge_702174;
int pconverge_702174;
int converge_688273;
int pconverge_688273;
int converge_702169;
int pconverge_702169;
int converge_688276;
int pconverge_688276;
int converge_702164;
int pconverge_702164;
int converge_688279;
int pconverge_688279;
int converge_702159;
int pconverge_702159;
int converge_688282;
int pconverge_688282;
int converge_702154;
int pconverge_702154;
int converge_688285;
int pconverge_688285;
int converge_702149;
int pconverge_702149;
int converge_688288;
int pconverge_688288;
int converge_702144;
int pconverge_702144;
int converge_688291;
int pconverge_688291;
int converge_702139;
int pconverge_702139;
int converge_688294;
int pconverge_688294;
int converge_702134;
int pconverge_702134;
int converge_688297;
int pconverge_688297;
int converge_702129;
int pconverge_702129;
int converge_688300;
int pconverge_688300;
int converge_702124;
int pconverge_702124;
int converge_688303;
int pconverge_688303;
int converge_702119;
int pconverge_702119;
int converge_688306;
int pconverge_688306;
int converge_702114;
int pconverge_702114;
int converge_688309;
int pconverge_688309;
int converge_702109;
int pconverge_702109;
int converge_688312;
int pconverge_688312;
int converge_702104;
int pconverge_702104;
int converge_688315;
int pconverge_688315;
int converge_702099;
int pconverge_702099;
int converge_688318;
int pconverge_688318;
int converge_702094;
int pconverge_702094;
int converge_688321;
int pconverge_688321;
int converge_702089;
int pconverge_702089;
int converge_688324;
int pconverge_688324;
int converge_702084;
int pconverge_702084;
int converge_688327;
int pconverge_688327;
int converge_702079;
int pconverge_702079;
int converge_688330;
int pconverge_688330;
int converge_702074;
int pconverge_702074;
int converge_688333;
int pconverge_688333;
int converge_702069;
int pconverge_702069;
int converge_688336;
int pconverge_688336;
int converge_702064;
int pconverge_702064;
int converge_688339;
int pconverge_688339;
int converge_702059;
int pconverge_702059;
int converge_688342;
int pconverge_688342;
int converge_702054;
int pconverge_702054;
int converge_688345;
int pconverge_688345;
int converge_702049;
int pconverge_702049;
int converge_688348;
int pconverge_688348;
int converge_702044;
int pconverge_702044;
int converge_688351;
int pconverge_688351;
int converge_702039;
int pconverge_702039;
int converge_688354;
int pconverge_688354;
int converge_702034;
int pconverge_702034;
int converge_688357;
int pconverge_688357;
int converge_702029;
int pconverge_702029;
int converge_688360;
int pconverge_688360;
int converge_702024;
int pconverge_702024;
int converge_688363;
int pconverge_688363;
int converge_702019;
int pconverge_702019;
int converge_688366;
int pconverge_688366;
int converge_702014;
int pconverge_702014;
int converge_688369;
int pconverge_688369;
int converge_702009;
int pconverge_702009;
int converge_688372;
int pconverge_688372;
int converge_702004;
int pconverge_702004;
int converge_688375;
int pconverge_688375;
int converge_701999;
int pconverge_701999;
int converge_688378;
int pconverge_688378;
int converge_701994;
int pconverge_701994;
int converge_688381;
int pconverge_688381;
int converge_701989;
int pconverge_701989;
int converge_688384;
int pconverge_688384;
int converge_701984;
int pconverge_701984;
int converge_688387;
int pconverge_688387;
int converge_701979;
int pconverge_701979;
int converge_688390;
int pconverge_688390;
int converge_701974;
int pconverge_701974;
int converge_688393;
int pconverge_688393;
int converge_701969;
int pconverge_701969;
int converge_688396;
int pconverge_688396;
int converge_701964;
int pconverge_701964;
int converge_688399;
int pconverge_688399;
int converge_701959;
int pconverge_701959;
int converge_688402;
int pconverge_688402;
int converge_701954;
int pconverge_701954;
int converge_688405;
int pconverge_688405;
int converge_701949;
int pconverge_701949;
int converge_688408;
int pconverge_688408;
int converge_701944;
int pconverge_701944;
int converge_688411;
int pconverge_688411;
int converge_701939;
int pconverge_701939;
int converge_688414;
int pconverge_688414;
int converge_701934;
int pconverge_701934;
int converge_688417;
int pconverge_688417;
int converge_701929;
int pconverge_701929;
int converge_688420;
int pconverge_688420;
int converge_701924;
int pconverge_701924;
int converge_688423;
int pconverge_688423;
int converge_701919;
int pconverge_701919;
int converge_688426;
int pconverge_688426;
int converge_701914;
int pconverge_701914;
int converge_688429;
int pconverge_688429;
int converge_701909;
int pconverge_701909;
int converge_688432;
int pconverge_688432;
int converge_701904;
int pconverge_701904;
int converge_688435;
int pconverge_688435;
int converge_701899;
int pconverge_701899;
int converge_688438;
int pconverge_688438;
int converge_701894;
int pconverge_701894;
int converge_688441;
int pconverge_688441;
int converge_701889;
int pconverge_701889;
int converge_688444;
int pconverge_688444;
int converge_701884;
int pconverge_701884;
int converge_688447;
int pconverge_688447;
int converge_701879;
int pconverge_701879;
int converge_688450;
int pconverge_688450;
int converge_701874;
int pconverge_701874;
int converge_688453;
int pconverge_688453;
int converge_701869;
int pconverge_701869;
int converge_688456;
int pconverge_688456;
int converge_701864;
int pconverge_701864;
int converge_688459;
int pconverge_688459;
int converge_701859;
int pconverge_701859;
int converge_688462;
int pconverge_688462;
int converge_701854;
int pconverge_701854;
int converge_688465;
int pconverge_688465;
int converge_701849;
int pconverge_701849;
int converge_688468;
int pconverge_688468;
int converge_701844;
int pconverge_701844;
int converge_688471;
int pconverge_688471;
int converge_701839;
int pconverge_701839;
int converge_688474;
int pconverge_688474;
int converge_701834;
int pconverge_701834;
int converge_688477;
int pconverge_688477;
int converge_701829;
int pconverge_701829;
int converge_688480;
int pconverge_688480;
int converge_701824;
int pconverge_701824;
int converge_688483;
int pconverge_688483;
int converge_701819;
int pconverge_701819;
int converge_688486;
int pconverge_688486;
int converge_701814;
int pconverge_701814;
int converge_688489;
int pconverge_688489;
int converge_701809;
int pconverge_701809;
int converge_688492;
int pconverge_688492;
int converge_701803;
int pconverge_701803;
int converge_688495;
int pconverge_688495;
int converge_701798;
int pconverge_701798;
int converge_688498;
int pconverge_688498;
int converge_701793;
int pconverge_701793;
int converge_688501;
int pconverge_688501;
int converge_701788;
int pconverge_701788;
int converge_688504;
int pconverge_688504;
int converge_701783;
int pconverge_701783;
int converge_688507;
int pconverge_688507;
int converge_701778;
int pconverge_701778;
int converge_688510;
int pconverge_688510;
int converge_701772;
int pconverge_701772;
int converge_688513;
int pconverge_688513;
int converge_701767;
int pconverge_701767;
int converge_688516;
int pconverge_688516;
int converge_701762;
int pconverge_701762;
int converge_688519;
int pconverge_688519;
int converge_701757;
int pconverge_701757;
int converge_688522;
int pconverge_688522;
int converge_701752;
int pconverge_701752;
int converge_688525;
int pconverge_688525;
int converge_701747;
int pconverge_701747;
int converge_688528;
int pconverge_688528;
int converge_701741;
int pconverge_701741;
int converge_688531;
int pconverge_688531;
int converge_701736;
int pconverge_701736;
int converge_688534;
int pconverge_688534;
int converge_701731;
int pconverge_701731;
int converge_688537;
int pconverge_688537;
int converge_701726;
int pconverge_701726;
int converge_688540;
int pconverge_688540;
int converge_701721;
int pconverge_701721;
int converge_688543;
int pconverge_688543;
int converge_701716;
int pconverge_701716;
int converge_688546;
int pconverge_688546;
int converge_701711;
int pconverge_701711;
int converge_688549;
int pconverge_688549;
int converge_701706;
int pconverge_701706;
int converge_688552;
int pconverge_688552;
int converge_701701;
int pconverge_701701;
int converge_688555;
int pconverge_688555;
int converge_701696;
int pconverge_701696;
int converge_688558;
int pconverge_688558;
int converge_701691;
int pconverge_701691;
int converge_688561;
int pconverge_688561;
int converge_701686;
int pconverge_701686;
int converge_688564;
int pconverge_688564;
int converge_701681;
int pconverge_701681;
int converge_688567;
int pconverge_688567;
int converge_701676;
int pconverge_701676;
int converge_688570;
int pconverge_688570;
int converge_701671;
int pconverge_701671;
int converge_688573;
int pconverge_688573;
int converge_701666;
int pconverge_701666;
int converge_688576;
int pconverge_688576;
int converge_701661;
int pconverge_701661;
int converge_688579;
int pconverge_688579;
int converge_701656;
int pconverge_701656;
int converge_688582;
int pconverge_688582;
int converge_701651;
int pconverge_701651;
int converge_688585;
int pconverge_688585;
int converge_701646;
int pconverge_701646;
int converge_688588;
int pconverge_688588;
int converge_701641;
int pconverge_701641;
int converge_688591;
int pconverge_688591;
int converge_701636;
int pconverge_701636;
int converge_688594;
int pconverge_688594;
int converge_701631;
int pconverge_701631;
int converge_688597;
int pconverge_688597;
int converge_701626;
int pconverge_701626;
int converge_688600;
int pconverge_688600;
int converge_701621;
int pconverge_701621;
int converge_688603;
int pconverge_688603;
int converge_701616;
int pconverge_701616;
int converge_688606;
int pconverge_688606;
int converge_701611;
int pconverge_701611;
int converge_688609;
int pconverge_688609;
int converge_701606;
int pconverge_701606;
int converge_688612;
int pconverge_688612;
int converge_701601;
int pconverge_701601;
int converge_688615;
int pconverge_688615;
int converge_701596;
int pconverge_701596;
int converge_688618;
int pconverge_688618;
int converge_701591;
int pconverge_701591;
int converge_688621;
int pconverge_688621;
int converge_701586;
int pconverge_701586;
int converge_688624;
int pconverge_688624;
int converge_701581;
int pconverge_701581;
int converge_688627;
int pconverge_688627;
int converge_701576;
int pconverge_701576;
int converge_688630;
int pconverge_688630;
int converge_701571;
int pconverge_701571;
int converge_688633;
int pconverge_688633;
int converge_701566;
int pconverge_701566;
int converge_688636;
int pconverge_688636;
int converge_701561;
int pconverge_701561;
int converge_688639;
int pconverge_688639;
int converge_701556;
int pconverge_701556;
int converge_688642;
int pconverge_688642;
int converge_701551;
int pconverge_701551;
int converge_688645;
int pconverge_688645;
int converge_701546;
int pconverge_701546;
int converge_688648;
int pconverge_688648;
int converge_701541;
int pconverge_701541;
int converge_688651;
int pconverge_688651;
int converge_701536;
int pconverge_701536;
int converge_688654;
int pconverge_688654;
int converge_701531;
int pconverge_701531;
int converge_688657;
int pconverge_688657;
int converge_701525;
int pconverge_701525;
int converge_688660;
int pconverge_688660;
int converge_701519;
int pconverge_701519;
int converge_688663;
int pconverge_688663;
int converge_701513;
int pconverge_701513;
int converge_688666;
int pconverge_688666;
int converge_701508;
int pconverge_701508;
int converge_688669;
int pconverge_688669;
int converge_701503;
int pconverge_701503;
int converge_688672;
int pconverge_688672;
int converge_701497;
int pconverge_701497;
int converge_688675;
int pconverge_688675;
int converge_701492;
int pconverge_701492;
int converge_688678;
int pconverge_688678;
int converge_701487;
int pconverge_701487;
int converge_688681;
int pconverge_688681;
int converge_701482;
int pconverge_701482;
int converge_688684;
int pconverge_688684;
int converge_701477;
int pconverge_701477;
int converge_688687;
int pconverge_688687;
int converge_701472;
int pconverge_701472;
int converge_688690;
int pconverge_688690;
int converge_701466;
int pconverge_701466;
int converge_688693;
int pconverge_688693;
int converge_701461;
int pconverge_701461;
int converge_688696;
int pconverge_688696;
int converge_701456;
int pconverge_701456;
int converge_688699;
int pconverge_688699;
int converge_701451;
int pconverge_701451;
int converge_688702;
int pconverge_688702;
int converge_701446;
int pconverge_701446;
int converge_688705;
int pconverge_688705;
int converge_701441;
int pconverge_701441;
int converge_688708;
int pconverge_688708;
int converge_701435;
int pconverge_701435;
int converge_688711;
int pconverge_688711;
int converge_701430;
int pconverge_701430;
int converge_688714;
int pconverge_688714;
int converge_701425;
int pconverge_701425;
int converge_688717;
int pconverge_688717;
int converge_701420;
int pconverge_701420;
int converge_688720;
int pconverge_688720;
int converge_701415;
int pconverge_701415;
int converge_688723;
int pconverge_688723;
int converge_701410;
int pconverge_701410;
int converge_688726;
int pconverge_688726;
int converge_701404;
int pconverge_701404;
int converge_688729;
int pconverge_688729;
int converge_701399;
int pconverge_701399;
int converge_688732;
int pconverge_688732;
int converge_701394;
int pconverge_701394;
int converge_688735;
int pconverge_688735;
int converge_701389;
int pconverge_701389;
int converge_688738;
int pconverge_688738;
int converge_701384;
int pconverge_701384;
int converge_688741;
int pconverge_688741;
int converge_701378;
int pconverge_701378;
int converge_688744;
int pconverge_688744;
int converge_701371;
int pconverge_701371;
int converge_688747;
int pconverge_688747;
int converge_701365;
int pconverge_701365;
int converge_688750;
int pconverge_688750;
int converge_701359;
int pconverge_701359;
int converge_688753;
int pconverge_688753;
int converge_701353;
int pconverge_701353;
int converge_688756;
int pconverge_688756;
int converge_701346;
int pconverge_701346;
int converge_688759;
int pconverge_688759;
threadIdx_x_681174 = threadIdx_x();
pthreadIdx_x_681174 = threadIdx_x_681174;
l681172: ;
threadIdx_x_681174 = pthreadIdx_x_681174;
blockDim_x_681180 = blockDim_x();
pblockDim_x_681180 = blockDim_x_681180;
l681178: ;
blockDim_x_681180 = pblockDim_x_681180;
blockIdx_x_681186 = blockIdx_x();
pblockIdx_x_681186 = blockIdx_x_681186;
l681184: ;
blockIdx_x_681186 = pblockIdx_x_681186;
_681192 = threadIdx_y();
p_681192 = _681192;
l681190: ;
_681192 = p_681192;
_681198 = blockDim_y();
p_681198 = _681198;
l681196: ;
_681198 = p_681198;
_681204 = blockIdx_y();
p_681204 = _681204;
l681202: ;
_681204 = p_681204;
_681207 = blockDim_y();
p_681207 = _681207;
l681205: ;
_681207 = p_681207;
int _681211;
_681211 = blockDim_x_681180 * blockIdx_x_681186;
int _681208;
_681208 = _681198 * _681204;
int _681212;
_681212 = threadIdx_x_681174 + _681211;
int gid_y_681209;
gid_y_681209 = _681192 + _681208;
int _681210;
_681210 = gid_y_681209 * _453090_681165;
int _681213;
_681213 = _681210 + _681212;
float* _681214;
_681214 = _453091_681166 + _681213;
float _681215;
_681215 = *_681214;
float _681217;
_681217 = _681215;
bool _681219;
_681219 = _681217 < 0.000000e+00f;
if (_681219) goto l681220; else goto l703767;
l703767: ;
bool _703768;
_703768 = 1.000000e+00f <= _681217;
if (_703768) goto l703769; else goto l703772;
l703772: ;
pconverge_703771 = _681217;
goto l703770;
l703769: ;
pconverge_703771 = 1.000000e+00f;
goto l703770;
l703770: ;
converge_703771 = pconverge_703771;
pconverge_681222 = converge_703771;
goto l681221;
l681220: ;
pconverge_681222 = 0.000000e+00f;
goto l681221;
l681221: ;
converge_681222 = pconverge_681222;
int gheight_701374;
gheight_701374 = _453092_681167 / 8;
int yi_681224;
yi_681224 = gid_y_681209 / 8;
int _701379;
_701379 = gheight_701374 - 1;
int _681226;
_681226 = yi_681224 - 2;
bool _681228;
_681228 = _681226 < 0;
bool _701806;
_701806 = gheight_701374 <= _681226;
if (_681228) goto l681229; else goto l703762;
l703762: ;
if (_701806) goto l703763; else goto l703766;
l703766: ;
pconverge_703765 = _681226;
goto l703764;
l703763: ;
pconverge_703765 = _701379;
goto l703764;
l703764: ;
converge_703765 = pconverge_703765;
pconverge_681231 = converge_703765;
goto l681230;
l681229: ;
pconverge_681231 = 0;
goto l681230;
l681230: ;
converge_681231 = pconverge_681231;
int xi_681232;
xi_681232 = _681212 / 8;
int gwidth_681983;
gwidth_681983 = _453090_681165 / 8;
int _681233;
_681233 = xi_681232 - 2;
bool _681234;
_681234 = _681233 < 0;
bool _701528;
_701528 = gwidth_681983 <= _681233;
int _701347;
_701347 = gwidth_681983 - 1;
if (_681234) goto l681235; else goto l703757;
l703757: ;
if (_701528) goto l703758; else goto l703761;
l703761: ;
pconverge_703760 = _681233;
goto l703759;
l703758: ;
pconverge_703760 = _701347;
goto l703759;
l703759: ;
converge_703760 = pconverge_703760;
pconverge_681237 = converge_703760;
goto l681236;
l681235: ;
pconverge_681237 = 0;
goto l681236;
l681236: ;
converge_681237 = pconverge_681237;
int _681239;
_681239 = xi_681232 - 1;
bool _681240;
_681240 = _681239 < 0;
bool _701522;
_701522 = gwidth_681983 <= _681239;
if (_681240) goto l681241; else goto l703752;
l703752: ;
if (_701522) goto l703753; else goto l703756;
l703756: ;
pconverge_703755 = _681239;
goto l703754;
l703753: ;
pconverge_703755 = _701347;
goto l703754;
l703754: ;
converge_703755 = pconverge_703755;
pconverge_681243 = converge_703755;
goto l681242;
l681241: ;
pconverge_681243 = 0;
goto l681242;
l681242: ;
converge_681243 = pconverge_681243;
bool _681244;
_681244 = xi_681232 < 0;
bool _701516;
_701516 = gwidth_681983 <= xi_681232;
if (_681244) goto l681245; else goto l703747;
l703747: ;
if (_701516) goto l703748; else goto l703751;
l703751: ;
pconverge_703750 = xi_681232;
goto l703749;
l703748: ;
pconverge_703750 = _701347;
goto l703749;
l703749: ;
converge_703750 = pconverge_703750;
pconverge_681247 = converge_703750;
goto l681246;
l681245: ;
pconverge_681247 = 0;
goto l681246;
l681246: ;
converge_681247 = pconverge_681247;
int _681248;
_681248 = 1 + xi_681232;
bool _701356;
_701356 = gwidth_681983 <= _681248;
bool _681249;
_681249 = _681248 < 0;
if (_681249) goto l681250; else goto l703742;
l703742: ;
if (_701356) goto l703743; else goto l703746;
l703746: ;
pconverge_703745 = _681248;
goto l703744;
l703743: ;
pconverge_703745 = _701347;
goto l703744;
l703744: ;
converge_703745 = pconverge_703745;
pconverge_681252 = converge_703745;
goto l681251;
l681250: ;
pconverge_681252 = 0;
goto l681251;
l681251: ;
converge_681252 = pconverge_681252;
int _681253;
_681253 = 2 + xi_681232;
bool _681254;
_681254 = _681253 < 0;
bool _701350;
_701350 = gwidth_681983 <= _681253;
if (_681254) goto l681255; else goto l703737;
l703737: ;
if (_701350) goto l703738; else goto l703741;
l703741: ;
pconverge_703740 = _681253;
goto l703739;
l703738: ;
pconverge_703740 = _701347;
goto l703739;
l703739: ;
converge_703740 = pconverge_703740;
pconverge_681257 = converge_703740;
goto l681256;
l681255: ;
pconverge_681257 = 0;
goto l681256;
l681256: ;
converge_681257 = pconverge_681257;
int _681258;
_681258 = yi_681224 - 1;
bool _681259;
_681259 = _681258 < 0;
bool _701775;
_701775 = gheight_701374 <= _681258;
if (_681259) goto l681260; else goto l703732;
l703732: ;
if (_701775) goto l703733; else goto l703736;
l703736: ;
pconverge_703735 = _681258;
goto l703734;
l703733: ;
pconverge_703735 = _701379;
goto l703734;
l703734: ;
converge_703735 = pconverge_703735;
pconverge_681262 = converge_703735;
goto l681261;
l681260: ;
pconverge_681262 = 0;
goto l681261;
l681261: ;
converge_681262 = pconverge_681262;
if (_681234) goto l681263; else goto l703727;
l703727: ;
if (_701528) goto l703728; else goto l703731;
l703731: ;
pconverge_703730 = _681233;
goto l703729;
l703728: ;
pconverge_703730 = _701347;
goto l703729;
l703729: ;
converge_703730 = pconverge_703730;
pconverge_681265 = converge_703730;
goto l681264;
l681263: ;
pconverge_681265 = 0;
goto l681264;
l681264: ;
converge_681265 = pconverge_681265;
if (_681240) goto l681266; else goto l703722;
l703722: ;
if (_701522) goto l703723; else goto l703726;
l703726: ;
pconverge_703725 = _681239;
goto l703724;
l703723: ;
pconverge_703725 = _701347;
goto l703724;
l703724: ;
converge_703725 = pconverge_703725;
pconverge_681268 = converge_703725;
goto l681267;
l681266: ;
pconverge_681268 = 0;
goto l681267;
l681267: ;
converge_681268 = pconverge_681268;
if (_681244) goto l681269; else goto l703717;
l703717: ;
if (_701516) goto l703718; else goto l703721;
l703721: ;
pconverge_703720 = xi_681232;
goto l703719;
l703718: ;
pconverge_703720 = _701347;
goto l703719;
l703719: ;
converge_703720 = pconverge_703720;
pconverge_681271 = converge_703720;
goto l681270;
l681269: ;
pconverge_681271 = 0;
goto l681270;
l681270: ;
converge_681271 = pconverge_681271;
if (_681249) goto l681272; else goto l703712;
l703712: ;
if (_701356) goto l703713; else goto l703716;
l703716: ;
pconverge_703715 = _681248;
goto l703714;
l703713: ;
pconverge_703715 = _701347;
goto l703714;
l703714: ;
converge_703715 = pconverge_703715;
pconverge_681274 = converge_703715;
goto l681273;
l681272: ;
pconverge_681274 = 0;
goto l681273;
l681273: ;
converge_681274 = pconverge_681274;
if (_681254) goto l681275; else goto l703707;
l703707: ;
if (_701350) goto l703708; else goto l703711;
l703711: ;
pconverge_703710 = _681253;
goto l703709;
l703708: ;
pconverge_703710 = _701347;
goto l703709;
l703709: ;
converge_703710 = pconverge_703710;
pconverge_681277 = converge_703710;
goto l681276;
l681275: ;
pconverge_681277 = 0;
goto l681276;
l681276: ;
converge_681277 = pconverge_681277;
bool _701744;
_701744 = gheight_701374 <= yi_681224;
bool _681278;
_681278 = yi_681224 < 0;
if (_681278) goto l681279; else goto l703702;
l703702: ;
if (_701744) goto l703703; else goto l703706;
l703706: ;
pconverge_703705 = yi_681224;
goto l703704;
l703703: ;
pconverge_703705 = _701379;
goto l703704;
l703704: ;
converge_703705 = pconverge_703705;
pconverge_681281 = converge_703705;
goto l681280;
l681279: ;
pconverge_681281 = 0;
goto l681280;
l681280: ;
converge_681281 = pconverge_681281;
if (_681234) goto l681282; else goto l703697;
l703697: ;
if (_701528) goto l703698; else goto l703701;
l703701: ;
pconverge_703700 = _681233;
goto l703699;
l703698: ;
pconverge_703700 = _701347;
goto l703699;
l703699: ;
converge_703700 = pconverge_703700;
pconverge_681284 = converge_703700;
goto l681283;
l681282: ;
pconverge_681284 = 0;
goto l681283;
l681283: ;
converge_681284 = pconverge_681284;
if (_681240) goto l681285; else goto l703692;
l703692: ;
if (_701522) goto l703693; else goto l703696;
l703696: ;
pconverge_703695 = _681239;
goto l703694;
l703693: ;
pconverge_703695 = _701347;
goto l703694;
l703694: ;
converge_703695 = pconverge_703695;
pconverge_681287 = converge_703695;
goto l681286;
l681285: ;
pconverge_681287 = 0;
goto l681286;
l681286: ;
converge_681287 = pconverge_681287;
if (_681244) goto l681288; else goto l703687;
l703687: ;
if (_701516) goto l703688; else goto l703691;
l703691: ;
pconverge_703690 = xi_681232;
goto l703689;
l703688: ;
pconverge_703690 = _701347;
goto l703689;
l703689: ;
converge_703690 = pconverge_703690;
pconverge_681290 = converge_703690;
goto l681289;
l681288: ;
pconverge_681290 = 0;
goto l681289;
l681289: ;
converge_681290 = pconverge_681290;
if (_681249) goto l681291; else goto l703682;
l703682: ;
if (_701356) goto l703683; else goto l703686;
l703686: ;
pconverge_703685 = _681248;
goto l703684;
l703683: ;
pconverge_703685 = _701347;
goto l703684;
l703684: ;
converge_703685 = pconverge_703685;
pconverge_681293 = converge_703685;
goto l681292;
l681291: ;
pconverge_681293 = 0;
goto l681292;
l681292: ;
converge_681293 = pconverge_681293;
if (_681254) goto l681294; else goto l703677;
l703677: ;
if (_701350) goto l703678; else goto l703681;
l703681: ;
pconverge_703680 = _681253;
goto l703679;
l703678: ;
pconverge_703680 = _701347;
goto l703679;
l703679: ;
converge_703680 = pconverge_703680;
pconverge_681296 = converge_703680;
goto l681295;
l681294: ;
pconverge_681296 = 0;
goto l681295;
l681295: ;
converge_681296 = pconverge_681296;
int _681297;
_681297 = 1 + yi_681224;
bool _701438;
_701438 = gheight_701374 <= _681297;
bool _681298;
_681298 = _681297 < 0;
if (_681298) goto l681299; else goto l703672;
l703672: ;
if (_701438) goto l703673; else goto l703676;
l703676: ;
pconverge_703675 = _681297;
goto l703674;
l703673: ;
pconverge_703675 = _701379;
goto l703674;
l703674: ;
converge_703675 = pconverge_703675;
pconverge_681301 = converge_703675;
goto l681300;
l681299: ;
pconverge_681301 = 0;
goto l681300;
l681300: ;
converge_681301 = pconverge_681301;
if (_681234) goto l681302; else goto l703667;
l703667: ;
if (_701528) goto l703668; else goto l703671;
l703671: ;
pconverge_703670 = _681233;
goto l703669;
l703668: ;
pconverge_703670 = _701347;
goto l703669;
l703669: ;
converge_703670 = pconverge_703670;
pconverge_681304 = converge_703670;
goto l681303;
l681302: ;
pconverge_681304 = 0;
goto l681303;
l681303: ;
converge_681304 = pconverge_681304;
if (_681240) goto l681305; else goto l703662;
l703662: ;
if (_701522) goto l703663; else goto l703666;
l703666: ;
pconverge_703665 = _681239;
goto l703664;
l703663: ;
pconverge_703665 = _701347;
goto l703664;
l703664: ;
converge_703665 = pconverge_703665;
pconverge_681307 = converge_703665;
goto l681306;
l681305: ;
pconverge_681307 = 0;
goto l681306;
l681306: ;
converge_681307 = pconverge_681307;
if (_681244) goto l681308; else goto l703657;
l703657: ;
if (_701516) goto l703658; else goto l703661;
l703661: ;
pconverge_703660 = xi_681232;
goto l703659;
l703658: ;
pconverge_703660 = _701347;
goto l703659;
l703659: ;
converge_703660 = pconverge_703660;
pconverge_681310 = converge_703660;
goto l681309;
l681308: ;
pconverge_681310 = 0;
goto l681309;
l681309: ;
converge_681310 = pconverge_681310;
if (_681249) goto l681311; else goto l703652;
l703652: ;
if (_701356) goto l703653; else goto l703656;
l703656: ;
pconverge_703655 = _681248;
goto l703654;
l703653: ;
pconverge_703655 = _701347;
goto l703654;
l703654: ;
converge_703655 = pconverge_703655;
pconverge_681313 = converge_703655;
goto l681312;
l681311: ;
pconverge_681313 = 0;
goto l681312;
l681312: ;
converge_681313 = pconverge_681313;
if (_681254) goto l681314; else goto l703647;
l703647: ;
if (_701350) goto l703648; else goto l703651;
l703651: ;
pconverge_703650 = _681253;
goto l703649;
l703648: ;
pconverge_703650 = _701347;
goto l703649;
l703649: ;
converge_703650 = pconverge_703650;
pconverge_681316 = converge_703650;
goto l681315;
l681314: ;
pconverge_681316 = 0;
goto l681315;
l681315: ;
converge_681316 = pconverge_681316;
int _681317;
_681317 = 2 + yi_681224;
bool _701407;
_701407 = gheight_701374 <= _681317;
bool _681318;
_681318 = _681317 < 0;
if (_681318) goto l681319; else goto l703642;
l703642: ;
if (_701407) goto l703643; else goto l703646;
l703646: ;
pconverge_703645 = _681317;
goto l703644;
l703643: ;
pconverge_703645 = _701379;
goto l703644;
l703644: ;
converge_703645 = pconverge_703645;
pconverge_681321 = converge_703645;
goto l681320;
l681319: ;
pconverge_681321 = 0;
goto l681320;
l681320: ;
converge_681321 = pconverge_681321;
if (_681234) goto l681322; else goto l703637;
l703637: ;
if (_701528) goto l703638; else goto l703641;
l703641: ;
pconverge_703640 = _681233;
goto l703639;
l703638: ;
pconverge_703640 = _701347;
goto l703639;
l703639: ;
converge_703640 = pconverge_703640;
pconverge_681324 = converge_703640;
goto l681323;
l681322: ;
pconverge_681324 = 0;
goto l681323;
l681323: ;
converge_681324 = pconverge_681324;
if (_681240) goto l681325; else goto l703632;
l703632: ;
if (_701522) goto l703633; else goto l703636;
l703636: ;
pconverge_703635 = _681239;
goto l703634;
l703633: ;
pconverge_703635 = _701347;
goto l703634;
l703634: ;
converge_703635 = pconverge_703635;
pconverge_681327 = converge_703635;
goto l681326;
l681325: ;
pconverge_681327 = 0;
goto l681326;
l681326: ;
converge_681327 = pconverge_681327;
if (_681244) goto l681328; else goto l703627;
l703627: ;
if (_701516) goto l703628; else goto l703631;
l703631: ;
pconverge_703630 = xi_681232;
goto l703629;
l703628: ;
pconverge_703630 = _701347;
goto l703629;
l703629: ;
converge_703630 = pconverge_703630;
pconverge_681330 = converge_703630;
goto l681329;
l681328: ;
pconverge_681330 = 0;
goto l681329;
l681329: ;
converge_681330 = pconverge_681330;
if (_681249) goto l681331; else goto l703622;
l703622: ;
if (_701356) goto l703623; else goto l703626;
l703626: ;
pconverge_703625 = _681248;
goto l703624;
l703623: ;
pconverge_703625 = _701347;
goto l703624;
l703624: ;
converge_703625 = pconverge_703625;
pconverge_681333 = converge_703625;
goto l681332;
l681331: ;
pconverge_681333 = 0;
goto l681332;
l681332: ;
converge_681333 = pconverge_681333;
if (_681254) goto l681334; else goto l703617;
l703617: ;
if (_701350) goto l703618; else goto l703621;
l703621: ;
pconverge_703620 = _681253;
goto l703619;
l703618: ;
pconverge_703620 = _701347;
goto l703619;
l703619: ;
converge_703620 = pconverge_703620;
pconverge_681336 = converge_703620;
goto l681335;
l681334: ;
pconverge_681336 = 0;
goto l681335;
l681335: ;
converge_681336 = pconverge_681336;
if (_681228) goto l681337; else goto l703612;
l703612: ;
if (_701806) goto l703613; else goto l703616;
l703616: ;
pconverge_703615 = _681226;
goto l703614;
l703613: ;
pconverge_703615 = _701379;
goto l703614;
l703614: ;
converge_703615 = pconverge_703615;
pconverge_681339 = converge_703615;
goto l681338;
l681337: ;
pconverge_681339 = 0;
goto l681338;
l681338: ;
converge_681339 = pconverge_681339;
int _681340;
_681340 = _681248 - 2;
bool _701368;
_701368 = gwidth_681983 <= _681340;
bool _681341;
_681341 = _681340 < 0;
if (_681341) goto l681342; else goto l703607;
l703607: ;
if (_701368) goto l703608; else goto l703611;
l703611: ;
pconverge_703610 = _681340;
goto l703609;
l703608: ;
pconverge_703610 = _701347;
goto l703609;
l703609: ;
converge_703610 = pconverge_703610;
pconverge_681344 = converge_703610;
goto l681343;
l681342: ;
pconverge_681344 = 0;
goto l681343;
l681343: ;
converge_681344 = pconverge_681344;
int _681345;
_681345 = _681248 - 1;
bool _681346;
_681346 = _681345 < 0;
bool _701362;
_701362 = gwidth_681983 <= _681345;
if (_681346) goto l681347; else goto l703602;
l703602: ;
if (_701362) goto l703603; else goto l703606;
l703606: ;
pconverge_703605 = _681345;
goto l703604;
l703603: ;
pconverge_703605 = _701347;
goto l703604;
l703604: ;
converge_703605 = pconverge_703605;
pconverge_681349 = converge_703605;
goto l681348;
l681347: ;
pconverge_681349 = 0;
goto l681348;
l681348: ;
converge_681349 = pconverge_681349;
if (_681249) goto l681350; else goto l703597;
l703597: ;
if (_701356) goto l703598; else goto l703601;
l703601: ;
pconverge_703600 = _681248;
goto l703599;
l703598: ;
pconverge_703600 = _701347;
goto l703599;
l703599: ;
converge_703600 = pconverge_703600;
pconverge_681352 = converge_703600;
goto l681351;
l681350: ;
pconverge_681352 = 0;
goto l681351;
l681351: ;
converge_681352 = pconverge_681352;
if (_681254) goto l681353; else goto l703592;
l703592: ;
if (_701350) goto l703593; else goto l703596;
l703596: ;
pconverge_703595 = _681253;
goto l703594;
l703593: ;
pconverge_703595 = _701347;
goto l703594;
l703594: ;
converge_703595 = pconverge_703595;
pconverge_681355 = converge_703595;
goto l681354;
l681353: ;
pconverge_681355 = 0;
goto l681354;
l681354: ;
converge_681355 = pconverge_681355;
int _681357;
_681357 = 3 + xi_681232;
bool _701343;
_701343 = gwidth_681983 <= _681357;
bool _681358;
_681358 = _681357 < 0;
if (_681358) goto l681359; else goto l703587;
l703587: ;
if (_701343) goto l703588; else goto l703591;
l703591: ;
pconverge_703590 = _681357;
goto l703589;
l703588: ;
pconverge_703590 = _701347;
goto l703589;
l703589: ;
converge_703590 = pconverge_703590;
pconverge_681361 = converge_703590;
goto l681360;
l681359: ;
pconverge_681361 = 0;
goto l681360;
l681360: ;
converge_681361 = pconverge_681361;
if (_681259) goto l681362; else goto l703582;
l703582: ;
if (_701775) goto l703583; else goto l703586;
l703586: ;
pconverge_703585 = _681258;
goto l703584;
l703583: ;
pconverge_703585 = _701379;
goto l703584;
l703584: ;
converge_703585 = pconverge_703585;
pconverge_681364 = converge_703585;
goto l681363;
l681362: ;
pconverge_681364 = 0;
goto l681363;
l681363: ;
converge_681364 = pconverge_681364;
if (_681341) goto l681365; else goto l703577;
l703577: ;
if (_701368) goto l703578; else goto l703581;
l703581: ;
pconverge_703580 = _681340;
goto l703579;
l703578: ;
pconverge_703580 = _701347;
goto l703579;
l703579: ;
converge_703580 = pconverge_703580;
pconverge_681367 = converge_703580;
goto l681366;
l681365: ;
pconverge_681367 = 0;
goto l681366;
l681366: ;
converge_681367 = pconverge_681367;
if (_681346) goto l681368; else goto l703572;
l703572: ;
if (_701362) goto l703573; else goto l703576;
l703576: ;
pconverge_703575 = _681345;
goto l703574;
l703573: ;
pconverge_703575 = _701347;
goto l703574;
l703574: ;
converge_703575 = pconverge_703575;
pconverge_681370 = converge_703575;
goto l681369;
l681368: ;
pconverge_681370 = 0;
goto l681369;
l681369: ;
converge_681370 = pconverge_681370;
if (_681249) goto l681371; else goto l703567;
l703567: ;
if (_701356) goto l703568; else goto l703571;
l703571: ;
pconverge_703570 = _681248;
goto l703569;
l703568: ;
pconverge_703570 = _701347;
goto l703569;
l703569: ;
converge_703570 = pconverge_703570;
pconverge_681373 = converge_703570;
goto l681372;
l681371: ;
pconverge_681373 = 0;
goto l681372;
l681372: ;
converge_681373 = pconverge_681373;
if (_681254) goto l681374; else goto l703562;
l703562: ;
if (_701350) goto l703563; else goto l703566;
l703566: ;
pconverge_703565 = _681253;
goto l703564;
l703563: ;
pconverge_703565 = _701347;
goto l703564;
l703564: ;
converge_703565 = pconverge_703565;
pconverge_681376 = converge_703565;
goto l681375;
l681374: ;
pconverge_681376 = 0;
goto l681375;
l681375: ;
converge_681376 = pconverge_681376;
if (_681358) goto l681377; else goto l703557;
l703557: ;
if (_701343) goto l703558; else goto l703561;
l703561: ;
pconverge_703560 = _681357;
goto l703559;
l703558: ;
pconverge_703560 = _701347;
goto l703559;
l703559: ;
converge_703560 = pconverge_703560;
pconverge_681379 = converge_703560;
goto l681378;
l681377: ;
pconverge_681379 = 0;
goto l681378;
l681378: ;
converge_681379 = pconverge_681379;
if (_681278) goto l681380; else goto l703552;
l703552: ;
if (_701744) goto l703553; else goto l703556;
l703556: ;
pconverge_703555 = yi_681224;
goto l703554;
l703553: ;
pconverge_703555 = _701379;
goto l703554;
l703554: ;
converge_703555 = pconverge_703555;
pconverge_681382 = converge_703555;
goto l681381;
l681380: ;
pconverge_681382 = 0;
goto l681381;
l681381: ;
converge_681382 = pconverge_681382;
if (_681341) goto l681383; else goto l703547;
l703547: ;
if (_701368) goto l703548; else goto l703551;
l703551: ;
pconverge_703550 = _681340;
goto l703549;
l703548: ;
pconverge_703550 = _701347;
goto l703549;
l703549: ;
converge_703550 = pconverge_703550;
pconverge_681385 = converge_703550;
goto l681384;
l681383: ;
pconverge_681385 = 0;
goto l681384;
l681384: ;
converge_681385 = pconverge_681385;
if (_681346) goto l681386; else goto l703542;
l703542: ;
if (_701362) goto l703543; else goto l703546;
l703546: ;
pconverge_703545 = _681345;
goto l703544;
l703543: ;
pconverge_703545 = _701347;
goto l703544;
l703544: ;
converge_703545 = pconverge_703545;
pconverge_681388 = converge_703545;
goto l681387;
l681386: ;
pconverge_681388 = 0;
goto l681387;
l681387: ;
converge_681388 = pconverge_681388;
if (_681249) goto l681389; else goto l703537;
l703537: ;
if (_701356) goto l703538; else goto l703541;
l703541: ;
pconverge_703540 = _681248;
goto l703539;
l703538: ;
pconverge_703540 = _701347;
goto l703539;
l703539: ;
converge_703540 = pconverge_703540;
pconverge_681391 = converge_703540;
goto l681390;
l681389: ;
pconverge_681391 = 0;
goto l681390;
l681390: ;
converge_681391 = pconverge_681391;
if (_681254) goto l681392; else goto l703532;
l703532: ;
if (_701350) goto l703533; else goto l703536;
l703536: ;
pconverge_703535 = _681253;
goto l703534;
l703533: ;
pconverge_703535 = _701347;
goto l703534;
l703534: ;
converge_703535 = pconverge_703535;
pconverge_681394 = converge_703535;
goto l681393;
l681392: ;
pconverge_681394 = 0;
goto l681393;
l681393: ;
converge_681394 = pconverge_681394;
if (_681358) goto l681395; else goto l703527;
l703527: ;
if (_701343) goto l703528; else goto l703531;
l703531: ;
pconverge_703530 = _681357;
goto l703529;
l703528: ;
pconverge_703530 = _701347;
goto l703529;
l703529: ;
converge_703530 = pconverge_703530;
pconverge_681397 = converge_703530;
goto l681396;
l681395: ;
pconverge_681397 = 0;
goto l681396;
l681396: ;
converge_681397 = pconverge_681397;
if (_681298) goto l681398; else goto l703522;
l703522: ;
if (_701438) goto l703523; else goto l703526;
l703526: ;
pconverge_703525 = _681297;
goto l703524;
l703523: ;
pconverge_703525 = _701379;
goto l703524;
l703524: ;
converge_703525 = pconverge_703525;
pconverge_681400 = converge_703525;
goto l681399;
l681398: ;
pconverge_681400 = 0;
goto l681399;
l681399: ;
converge_681400 = pconverge_681400;
if (_681341) goto l681401; else goto l703517;
l703517: ;
if (_701368) goto l703518; else goto l703521;
l703521: ;
pconverge_703520 = _681340;
goto l703519;
l703518: ;
pconverge_703520 = _701347;
goto l703519;
l703519: ;
converge_703520 = pconverge_703520;
pconverge_681403 = converge_703520;
goto l681402;
l681401: ;
pconverge_681403 = 0;
goto l681402;
l681402: ;
converge_681403 = pconverge_681403;
if (_681346) goto l681404; else goto l703512;
l703512: ;
if (_701362) goto l703513; else goto l703516;
l703516: ;
pconverge_703515 = _681345;
goto l703514;
l703513: ;
pconverge_703515 = _701347;
goto l703514;
l703514: ;
converge_703515 = pconverge_703515;
pconverge_681406 = converge_703515;
goto l681405;
l681404: ;
pconverge_681406 = 0;
goto l681405;
l681405: ;
converge_681406 = pconverge_681406;
if (_681249) goto l681407; else goto l703507;
l703507: ;
if (_701356) goto l703508; else goto l703511;
l703511: ;
pconverge_703510 = _681248;
goto l703509;
l703508: ;
pconverge_703510 = _701347;
goto l703509;
l703509: ;
converge_703510 = pconverge_703510;
pconverge_681409 = converge_703510;
goto l681408;
l681407: ;
pconverge_681409 = 0;
goto l681408;
l681408: ;
converge_681409 = pconverge_681409;
if (_681254) goto l681410; else goto l703502;
l703502: ;
if (_701350) goto l703503; else goto l703506;
l703506: ;
pconverge_703505 = _681253;
goto l703504;
l703503: ;
pconverge_703505 = _701347;
goto l703504;
l703504: ;
converge_703505 = pconverge_703505;
pconverge_681412 = converge_703505;
goto l681411;
l681410: ;
pconverge_681412 = 0;
goto l681411;
l681411: ;
converge_681412 = pconverge_681412;
if (_681358) goto l681413; else goto l703497;
l703497: ;
if (_701343) goto l703498; else goto l703501;
l703501: ;
pconverge_703500 = _681357;
goto l703499;
l703498: ;
pconverge_703500 = _701347;
goto l703499;
l703499: ;
converge_703500 = pconverge_703500;
pconverge_681415 = converge_703500;
goto l681414;
l681413: ;
pconverge_681415 = 0;
goto l681414;
l681414: ;
converge_681415 = pconverge_681415;
if (_681318) goto l681416; else goto l703492;
l703492: ;
if (_701407) goto l703493; else goto l703496;
l703496: ;
pconverge_703495 = _681317;
goto l703494;
l703493: ;
pconverge_703495 = _701379;
goto l703494;
l703494: ;
converge_703495 = pconverge_703495;
pconverge_681418 = converge_703495;
goto l681417;
l681416: ;
pconverge_681418 = 0;
goto l681417;
l681417: ;
converge_681418 = pconverge_681418;
if (_681341) goto l681419; else goto l703487;
l703487: ;
if (_701368) goto l703488; else goto l703491;
l703491: ;
pconverge_703490 = _681340;
goto l703489;
l703488: ;
pconverge_703490 = _701347;
goto l703489;
l703489: ;
converge_703490 = pconverge_703490;
pconverge_681421 = converge_703490;
goto l681420;
l681419: ;
pconverge_681421 = 0;
goto l681420;
l681420: ;
converge_681421 = pconverge_681421;
if (_681346) goto l681422; else goto l703482;
l703482: ;
if (_701362) goto l703483; else goto l703486;
l703486: ;
pconverge_703485 = _681345;
goto l703484;
l703483: ;
pconverge_703485 = _701347;
goto l703484;
l703484: ;
converge_703485 = pconverge_703485;
pconverge_681424 = converge_703485;
goto l681423;
l681422: ;
pconverge_681424 = 0;
goto l681423;
l681423: ;
converge_681424 = pconverge_681424;
if (_681249) goto l681425; else goto l703477;
l703477: ;
if (_701356) goto l703478; else goto l703481;
l703481: ;
pconverge_703480 = _681248;
goto l703479;
l703478: ;
pconverge_703480 = _701347;
goto l703479;
l703479: ;
converge_703480 = pconverge_703480;
pconverge_681427 = converge_703480;
goto l681426;
l681425: ;
pconverge_681427 = 0;
goto l681426;
l681426: ;
converge_681427 = pconverge_681427;
if (_681254) goto l681428; else goto l703472;
l703472: ;
if (_701350) goto l703473; else goto l703476;
l703476: ;
pconverge_703475 = _681253;
goto l703474;
l703473: ;
pconverge_703475 = _701347;
goto l703474;
l703474: ;
converge_703475 = pconverge_703475;
pconverge_681430 = converge_703475;
goto l681429;
l681428: ;
pconverge_681430 = 0;
goto l681429;
l681429: ;
converge_681430 = pconverge_681430;
if (_681358) goto l681431; else goto l703467;
l703467: ;
if (_701343) goto l703468; else goto l703471;
l703471: ;
pconverge_703470 = _681357;
goto l703469;
l703468: ;
pconverge_703470 = _701347;
goto l703469;
l703469: ;
converge_703470 = pconverge_703470;
pconverge_681433 = converge_703470;
goto l681432;
l681431: ;
pconverge_681433 = 0;
goto l681432;
l681432: ;
converge_681433 = pconverge_681433;
int _681434;
_681434 = _681297 - 2;
bool _701500;
_701500 = gheight_701374 <= _681434;
bool _681435;
_681435 = _681434 < 0;
if (_681435) goto l681436; else goto l703462;
l703462: ;
if (_701500) goto l703463; else goto l703466;
l703466: ;
pconverge_703465 = _681434;
goto l703464;
l703463: ;
pconverge_703465 = _701379;
goto l703464;
l703464: ;
converge_703465 = pconverge_703465;
pconverge_681438 = converge_703465;
goto l681437;
l681436: ;
pconverge_681438 = 0;
goto l681437;
l681437: ;
converge_681438 = pconverge_681438;
if (_681234) goto l681439; else goto l703457;
l703457: ;
if (_701528) goto l703458; else goto l703461;
l703461: ;
pconverge_703460 = _681233;
goto l703459;
l703458: ;
pconverge_703460 = _701347;
goto l703459;
l703459: ;
converge_703460 = pconverge_703460;
pconverge_681441 = converge_703460;
goto l681440;
l681439: ;
pconverge_681441 = 0;
goto l681440;
l681440: ;
converge_681441 = pconverge_681441;
if (_681240) goto l681442; else goto l703452;
l703452: ;
if (_701522) goto l703453; else goto l703456;
l703456: ;
pconverge_703455 = _681239;
goto l703454;
l703453: ;
pconverge_703455 = _701347;
goto l703454;
l703454: ;
converge_703455 = pconverge_703455;
pconverge_681444 = converge_703455;
goto l681443;
l681442: ;
pconverge_681444 = 0;
goto l681443;
l681443: ;
converge_681444 = pconverge_681444;
if (_681244) goto l681445; else goto l703447;
l703447: ;
if (_701516) goto l703448; else goto l703451;
l703451: ;
pconverge_703450 = xi_681232;
goto l703449;
l703448: ;
pconverge_703450 = _701347;
goto l703449;
l703449: ;
converge_703450 = pconverge_703450;
pconverge_681447 = converge_703450;
goto l681446;
l681445: ;
pconverge_681447 = 0;
goto l681446;
l681446: ;
converge_681447 = pconverge_681447;
if (_681249) goto l681448; else goto l703442;
l703442: ;
if (_701356) goto l703443; else goto l703446;
l703446: ;
pconverge_703445 = _681248;
goto l703444;
l703443: ;
pconverge_703445 = _701347;
goto l703444;
l703444: ;
converge_703445 = pconverge_703445;
pconverge_681450 = converge_703445;
goto l681449;
l681448: ;
pconverge_681450 = 0;
goto l681449;
l681449: ;
converge_681450 = pconverge_681450;
if (_681254) goto l681451; else goto l703437;
l703437: ;
if (_701350) goto l703438; else goto l703441;
l703441: ;
pconverge_703440 = _681253;
goto l703439;
l703438: ;
pconverge_703440 = _701347;
goto l703439;
l703439: ;
converge_703440 = pconverge_703440;
pconverge_681453 = converge_703440;
goto l681452;
l681451: ;
pconverge_681453 = 0;
goto l681452;
l681452: ;
converge_681453 = pconverge_681453;
int _681454;
_681454 = _681297 - 1;
bool _681455;
_681455 = _681454 < 0;
bool _701469;
_701469 = gheight_701374 <= _681454;
if (_681455) goto l681456; else goto l703432;
l703432: ;
if (_701469) goto l703433; else goto l703436;
l703436: ;
pconverge_703435 = _681454;
goto l703434;
l703433: ;
pconverge_703435 = _701379;
goto l703434;
l703434: ;
converge_703435 = pconverge_703435;
pconverge_681458 = converge_703435;
goto l681457;
l681456: ;
pconverge_681458 = 0;
goto l681457;
l681457: ;
converge_681458 = pconverge_681458;
if (_681234) goto l681459; else goto l703427;
l703427: ;
if (_701528) goto l703428; else goto l703431;
l703431: ;
pconverge_703430 = _681233;
goto l703429;
l703428: ;
pconverge_703430 = _701347;
goto l703429;
l703429: ;
converge_703430 = pconverge_703430;
pconverge_681461 = converge_703430;
goto l681460;
l681459: ;
pconverge_681461 = 0;
goto l681460;
l681460: ;
converge_681461 = pconverge_681461;
if (_681240) goto l681462; else goto l703422;
l703422: ;
if (_701522) goto l703423; else goto l703426;
l703426: ;
pconverge_703425 = _681239;
goto l703424;
l703423: ;
pconverge_703425 = _701347;
goto l703424;
l703424: ;
converge_703425 = pconverge_703425;
pconverge_681464 = converge_703425;
goto l681463;
l681462: ;
pconverge_681464 = 0;
goto l681463;
l681463: ;
converge_681464 = pconverge_681464;
if (_681244) goto l681465; else goto l703417;
l703417: ;
if (_701516) goto l703418; else goto l703421;
l703421: ;
pconverge_703420 = xi_681232;
goto l703419;
l703418: ;
pconverge_703420 = _701347;
goto l703419;
l703419: ;
converge_703420 = pconverge_703420;
pconverge_681467 = converge_703420;
goto l681466;
l681465: ;
pconverge_681467 = 0;
goto l681466;
l681466: ;
converge_681467 = pconverge_681467;
if (_681249) goto l681468; else goto l703412;
l703412: ;
if (_701356) goto l703413; else goto l703416;
l703416: ;
pconverge_703415 = _681248;
goto l703414;
l703413: ;
pconverge_703415 = _701347;
goto l703414;
l703414: ;
converge_703415 = pconverge_703415;
pconverge_681470 = converge_703415;
goto l681469;
l681468: ;
pconverge_681470 = 0;
goto l681469;
l681469: ;
converge_681470 = pconverge_681470;
if (_681254) goto l681471; else goto l703407;
l703407: ;
if (_701350) goto l703408; else goto l703411;
l703411: ;
pconverge_703410 = _681253;
goto l703409;
l703408: ;
pconverge_703410 = _701347;
goto l703409;
l703409: ;
converge_703410 = pconverge_703410;
pconverge_681473 = converge_703410;
goto l681472;
l681471: ;
pconverge_681473 = 0;
goto l681472;
l681472: ;
converge_681473 = pconverge_681473;
if (_681298) goto l681474; else goto l703402;
l703402: ;
if (_701438) goto l703403; else goto l703406;
l703406: ;
pconverge_703405 = _681297;
goto l703404;
l703403: ;
pconverge_703405 = _701379;
goto l703404;
l703404: ;
converge_703405 = pconverge_703405;
pconverge_681476 = converge_703405;
goto l681475;
l681474: ;
pconverge_681476 = 0;
goto l681475;
l681475: ;
converge_681476 = pconverge_681476;
if (_681234) goto l681477; else goto l703397;
l703397: ;
if (_701528) goto l703398; else goto l703401;
l703401: ;
pconverge_703400 = _681233;
goto l703399;
l703398: ;
pconverge_703400 = _701347;
goto l703399;
l703399: ;
converge_703400 = pconverge_703400;
pconverge_681479 = converge_703400;
goto l681478;
l681477: ;
pconverge_681479 = 0;
goto l681478;
l681478: ;
converge_681479 = pconverge_681479;
if (_681240) goto l681480; else goto l703392;
l703392: ;
if (_701522) goto l703393; else goto l703396;
l703396: ;
pconverge_703395 = _681239;
goto l703394;
l703393: ;
pconverge_703395 = _701347;
goto l703394;
l703394: ;
converge_703395 = pconverge_703395;
pconverge_681482 = converge_703395;
goto l681481;
l681480: ;
pconverge_681482 = 0;
goto l681481;
l681481: ;
converge_681482 = pconverge_681482;
if (_681244) goto l681483; else goto l703387;
l703387: ;
if (_701516) goto l703388; else goto l703391;
l703391: ;
pconverge_703390 = xi_681232;
goto l703389;
l703388: ;
pconverge_703390 = _701347;
goto l703389;
l703389: ;
converge_703390 = pconverge_703390;
pconverge_681485 = converge_703390;
goto l681484;
l681483: ;
pconverge_681485 = 0;
goto l681484;
l681484: ;
converge_681485 = pconverge_681485;
if (_681249) goto l681486; else goto l703382;
l703382: ;
if (_701356) goto l703383; else goto l703386;
l703386: ;
pconverge_703385 = _681248;
goto l703384;
l703383: ;
pconverge_703385 = _701347;
goto l703384;
l703384: ;
converge_703385 = pconverge_703385;
pconverge_681488 = converge_703385;
goto l681487;
l681486: ;
pconverge_681488 = 0;
goto l681487;
l681487: ;
converge_681488 = pconverge_681488;
if (_681254) goto l681489; else goto l703377;
l703377: ;
if (_701350) goto l703378; else goto l703381;
l703381: ;
pconverge_703380 = _681253;
goto l703379;
l703378: ;
pconverge_703380 = _701347;
goto l703379;
l703379: ;
converge_703380 = pconverge_703380;
pconverge_681491 = converge_703380;
goto l681490;
l681489: ;
pconverge_681491 = 0;
goto l681490;
l681490: ;
converge_681491 = pconverge_681491;
if (_681318) goto l681492; else goto l703372;
l703372: ;
if (_701407) goto l703373; else goto l703376;
l703376: ;
pconverge_703375 = _681317;
goto l703374;
l703373: ;
pconverge_703375 = _701379;
goto l703374;
l703374: ;
converge_703375 = pconverge_703375;
pconverge_681494 = converge_703375;
goto l681493;
l681492: ;
pconverge_681494 = 0;
goto l681493;
l681493: ;
converge_681494 = pconverge_681494;
if (_681234) goto l681495; else goto l703367;
l703367: ;
if (_701528) goto l703368; else goto l703371;
l703371: ;
pconverge_703370 = _681233;
goto l703369;
l703368: ;
pconverge_703370 = _701347;
goto l703369;
l703369: ;
converge_703370 = pconverge_703370;
pconverge_681497 = converge_703370;
goto l681496;
l681495: ;
pconverge_681497 = 0;
goto l681496;
l681496: ;
converge_681497 = pconverge_681497;
if (_681240) goto l681498; else goto l703362;
l703362: ;
if (_701522) goto l703363; else goto l703366;
l703366: ;
pconverge_703365 = _681239;
goto l703364;
l703363: ;
pconverge_703365 = _701347;
goto l703364;
l703364: ;
converge_703365 = pconverge_703365;
pconverge_681500 = converge_703365;
goto l681499;
l681498: ;
pconverge_681500 = 0;
goto l681499;
l681499: ;
converge_681500 = pconverge_681500;
if (_681244) goto l681501; else goto l703357;
l703357: ;
if (_701516) goto l703358; else goto l703361;
l703361: ;
pconverge_703360 = xi_681232;
goto l703359;
l703358: ;
pconverge_703360 = _701347;
goto l703359;
l703359: ;
converge_703360 = pconverge_703360;
pconverge_681503 = converge_703360;
goto l681502;
l681501: ;
pconverge_681503 = 0;
goto l681502;
l681502: ;
converge_681503 = pconverge_681503;
if (_681249) goto l681504; else goto l703352;
l703352: ;
if (_701356) goto l703353; else goto l703356;
l703356: ;
pconverge_703355 = _681248;
goto l703354;
l703353: ;
pconverge_703355 = _701347;
goto l703354;
l703354: ;
converge_703355 = pconverge_703355;
pconverge_681506 = converge_703355;
goto l681505;
l681504: ;
pconverge_681506 = 0;
goto l681505;
l681505: ;
converge_681506 = pconverge_681506;
if (_681254) goto l681507; else goto l703347;
l703347: ;
if (_701350) goto l703348; else goto l703351;
l703351: ;
pconverge_703350 = _681253;
goto l703349;
l703348: ;
pconverge_703350 = _701347;
goto l703349;
l703349: ;
converge_703350 = pconverge_703350;
pconverge_681509 = converge_703350;
goto l681508;
l681507: ;
pconverge_681509 = 0;
goto l681508;
l681508: ;
converge_681509 = pconverge_681509;
int _681510;
_681510 = 3 + yi_681224;
bool _701375;
_701375 = gheight_701374 <= _681510;
bool _681511;
_681511 = _681510 < 0;
if (_681511) goto l681512; else goto l703342;
l703342: ;
if (_701375) goto l703343; else goto l703346;
l703346: ;
pconverge_703345 = _681510;
goto l703344;
l703343: ;
pconverge_703345 = _701379;
goto l703344;
l703344: ;
converge_703345 = pconverge_703345;
pconverge_681514 = converge_703345;
goto l681513;
l681512: ;
pconverge_681514 = 0;
goto l681513;
l681513: ;
converge_681514 = pconverge_681514;
if (_681234) goto l681515; else goto l703337;
l703337: ;
if (_701528) goto l703338; else goto l703341;
l703341: ;
pconverge_703340 = _681233;
goto l703339;
l703338: ;
pconverge_703340 = _701347;
goto l703339;
l703339: ;
converge_703340 = pconverge_703340;
pconverge_681517 = converge_703340;
goto l681516;
l681515: ;
pconverge_681517 = 0;
goto l681516;
l681516: ;
converge_681517 = pconverge_681517;
if (_681240) goto l681518; else goto l703332;
l703332: ;
if (_701522) goto l703333; else goto l703336;
l703336: ;
pconverge_703335 = _681239;
goto l703334;
l703333: ;
pconverge_703335 = _701347;
goto l703334;
l703334: ;
converge_703335 = pconverge_703335;
pconverge_681520 = converge_703335;
goto l681519;
l681518: ;
pconverge_681520 = 0;
goto l681519;
l681519: ;
converge_681520 = pconverge_681520;
if (_681244) goto l681521; else goto l703327;
l703327: ;
if (_701516) goto l703328; else goto l703331;
l703331: ;
pconverge_703330 = xi_681232;
goto l703329;
l703328: ;
pconverge_703330 = _701347;
goto l703329;
l703329: ;
converge_703330 = pconverge_703330;
pconverge_681523 = converge_703330;
goto l681522;
l681521: ;
pconverge_681523 = 0;
goto l681522;
l681522: ;
converge_681523 = pconverge_681523;
if (_681249) goto l681524; else goto l703322;
l703322: ;
if (_701356) goto l703323; else goto l703326;
l703326: ;
pconverge_703325 = _681248;
goto l703324;
l703323: ;
pconverge_703325 = _701347;
goto l703324;
l703324: ;
converge_703325 = pconverge_703325;
pconverge_681526 = converge_703325;
goto l681525;
l681524: ;
pconverge_681526 = 0;
goto l681525;
l681525: ;
converge_681526 = pconverge_681526;
if (_681254) goto l681527; else goto l703317;
l703317: ;
if (_701350) goto l703318; else goto l703321;
l703321: ;
pconverge_703320 = _681253;
goto l703319;
l703318: ;
pconverge_703320 = _701347;
goto l703319;
l703319: ;
converge_703320 = pconverge_703320;
pconverge_681529 = converge_703320;
goto l681528;
l681527: ;
pconverge_681529 = 0;
goto l681528;
l681528: ;
converge_681529 = pconverge_681529;
if (_681435) goto l681530; else goto l703312;
l703312: ;
if (_701500) goto l703313; else goto l703316;
l703316: ;
pconverge_703315 = _681434;
goto l703314;
l703313: ;
pconverge_703315 = _701379;
goto l703314;
l703314: ;
converge_703315 = pconverge_703315;
pconverge_681532 = converge_703315;
goto l681531;
l681530: ;
pconverge_681532 = 0;
goto l681531;
l681531: ;
converge_681532 = pconverge_681532;
if (_681341) goto l681533; else goto l703307;
l703307: ;
if (_701368) goto l703308; else goto l703311;
l703311: ;
pconverge_703310 = _681340;
goto l703309;
l703308: ;
pconverge_703310 = _701347;
goto l703309;
l703309: ;
converge_703310 = pconverge_703310;
pconverge_681535 = converge_703310;
goto l681534;
l681533: ;
pconverge_681535 = 0;
goto l681534;
l681534: ;
converge_681535 = pconverge_681535;
if (_681346) goto l681536; else goto l703302;
l703302: ;
if (_701362) goto l703303; else goto l703306;
l703306: ;
pconverge_703305 = _681345;
goto l703304;
l703303: ;
pconverge_703305 = _701347;
goto l703304;
l703304: ;
converge_703305 = pconverge_703305;
pconverge_681538 = converge_703305;
goto l681537;
l681536: ;
pconverge_681538 = 0;
goto l681537;
l681537: ;
converge_681538 = pconverge_681538;
if (_681249) goto l681539; else goto l703297;
l703297: ;
if (_701356) goto l703298; else goto l703301;
l703301: ;
pconverge_703300 = _681248;
goto l703299;
l703298: ;
pconverge_703300 = _701347;
goto l703299;
l703299: ;
converge_703300 = pconverge_703300;
pconverge_681541 = converge_703300;
goto l681540;
l681539: ;
pconverge_681541 = 0;
goto l681540;
l681540: ;
converge_681541 = pconverge_681541;
if (_681254) goto l681542; else goto l703292;
l703292: ;
if (_701350) goto l703293; else goto l703296;
l703296: ;
pconverge_703295 = _681253;
goto l703294;
l703293: ;
pconverge_703295 = _701347;
goto l703294;
l703294: ;
converge_703295 = pconverge_703295;
pconverge_681544 = converge_703295;
goto l681543;
l681542: ;
pconverge_681544 = 0;
goto l681543;
l681543: ;
converge_681544 = pconverge_681544;
if (_681358) goto l681545; else goto l703287;
l703287: ;
if (_701343) goto l703288; else goto l703291;
l703291: ;
pconverge_703290 = _681357;
goto l703289;
l703288: ;
pconverge_703290 = _701347;
goto l703289;
l703289: ;
converge_703290 = pconverge_703290;
pconverge_681547 = converge_703290;
goto l681546;
l681545: ;
pconverge_681547 = 0;
goto l681546;
l681546: ;
converge_681547 = pconverge_681547;
if (_681455) goto l681548; else goto l703282;
l703282: ;
if (_701469) goto l703283; else goto l703286;
l703286: ;
pconverge_703285 = _681454;
goto l703284;
l703283: ;
pconverge_703285 = _701379;
goto l703284;
l703284: ;
converge_703285 = pconverge_703285;
pconverge_681550 = converge_703285;
goto l681549;
l681548: ;
pconverge_681550 = 0;
goto l681549;
l681549: ;
converge_681550 = pconverge_681550;
if (_681341) goto l681551; else goto l703277;
l703277: ;
if (_701368) goto l703278; else goto l703281;
l703281: ;
pconverge_703280 = _681340;
goto l703279;
l703278: ;
pconverge_703280 = _701347;
goto l703279;
l703279: ;
converge_703280 = pconverge_703280;
pconverge_681553 = converge_703280;
goto l681552;
l681551: ;
pconverge_681553 = 0;
goto l681552;
l681552: ;
converge_681553 = pconverge_681553;
if (_681346) goto l681554; else goto l703272;
l703272: ;
if (_701362) goto l703273; else goto l703276;
l703276: ;
pconverge_703275 = _681345;
goto l703274;
l703273: ;
pconverge_703275 = _701347;
goto l703274;
l703274: ;
converge_703275 = pconverge_703275;
pconverge_681556 = converge_703275;
goto l681555;
l681554: ;
pconverge_681556 = 0;
goto l681555;
l681555: ;
converge_681556 = pconverge_681556;
if (_681249) goto l681557; else goto l703267;
l703267: ;
if (_701356) goto l703268; else goto l703271;
l703271: ;
pconverge_703270 = _681248;
goto l703269;
l703268: ;
pconverge_703270 = _701347;
goto l703269;
l703269: ;
converge_703270 = pconverge_703270;
pconverge_681559 = converge_703270;
goto l681558;
l681557: ;
pconverge_681559 = 0;
goto l681558;
l681558: ;
converge_681559 = pconverge_681559;
if (_681254) goto l681560; else goto l703262;
l703262: ;
if (_701350) goto l703263; else goto l703266;
l703266: ;
pconverge_703265 = _681253;
goto l703264;
l703263: ;
pconverge_703265 = _701347;
goto l703264;
l703264: ;
converge_703265 = pconverge_703265;
pconverge_681562 = converge_703265;
goto l681561;
l681560: ;
pconverge_681562 = 0;
goto l681561;
l681561: ;
converge_681562 = pconverge_681562;
if (_681358) goto l681563; else goto l703257;
l703257: ;
if (_701343) goto l703258; else goto l703261;
l703261: ;
pconverge_703260 = _681357;
goto l703259;
l703258: ;
pconverge_703260 = _701347;
goto l703259;
l703259: ;
converge_703260 = pconverge_703260;
pconverge_681565 = converge_703260;
goto l681564;
l681563: ;
pconverge_681565 = 0;
goto l681564;
l681564: ;
converge_681565 = pconverge_681565;
if (_681298) goto l681566; else goto l703252;
l703252: ;
if (_701438) goto l703253; else goto l703256;
l703256: ;
pconverge_703255 = _681297;
goto l703254;
l703253: ;
pconverge_703255 = _701379;
goto l703254;
l703254: ;
converge_703255 = pconverge_703255;
pconverge_681568 = converge_703255;
goto l681567;
l681566: ;
pconverge_681568 = 0;
goto l681567;
l681567: ;
converge_681568 = pconverge_681568;
if (_681341) goto l681569; else goto l703247;
l703247: ;
if (_701368) goto l703248; else goto l703251;
l703251: ;
pconverge_703250 = _681340;
goto l703249;
l703248: ;
pconverge_703250 = _701347;
goto l703249;
l703249: ;
converge_703250 = pconverge_703250;
pconverge_681571 = converge_703250;
goto l681570;
l681569: ;
pconverge_681571 = 0;
goto l681570;
l681570: ;
converge_681571 = pconverge_681571;
if (_681346) goto l681572; else goto l703242;
l703242: ;
if (_701362) goto l703243; else goto l703246;
l703246: ;
pconverge_703245 = _681345;
goto l703244;
l703243: ;
pconverge_703245 = _701347;
goto l703244;
l703244: ;
converge_703245 = pconverge_703245;
pconverge_681574 = converge_703245;
goto l681573;
l681572: ;
pconverge_681574 = 0;
goto l681573;
l681573: ;
converge_681574 = pconverge_681574;
if (_681249) goto l681575; else goto l703237;
l703237: ;
if (_701356) goto l703238; else goto l703241;
l703241: ;
pconverge_703240 = _681248;
goto l703239;
l703238: ;
pconverge_703240 = _701347;
goto l703239;
l703239: ;
converge_703240 = pconverge_703240;
pconverge_681577 = converge_703240;
goto l681576;
l681575: ;
pconverge_681577 = 0;
goto l681576;
l681576: ;
converge_681577 = pconverge_681577;
if (_681254) goto l681578; else goto l703232;
l703232: ;
if (_701350) goto l703233; else goto l703236;
l703236: ;
pconverge_703235 = _681253;
goto l703234;
l703233: ;
pconverge_703235 = _701347;
goto l703234;
l703234: ;
converge_703235 = pconverge_703235;
pconverge_681580 = converge_703235;
goto l681579;
l681578: ;
pconverge_681580 = 0;
goto l681579;
l681579: ;
converge_681580 = pconverge_681580;
if (_681358) goto l681581; else goto l703227;
l703227: ;
if (_701343) goto l703228; else goto l703231;
l703231: ;
pconverge_703230 = _681357;
goto l703229;
l703228: ;
pconverge_703230 = _701347;
goto l703229;
l703229: ;
converge_703230 = pconverge_703230;
pconverge_681583 = converge_703230;
goto l681582;
l681581: ;
pconverge_681583 = 0;
goto l681582;
l681582: ;
converge_681583 = pconverge_681583;
if (_681318) goto l681584; else goto l703222;
l703222: ;
if (_701407) goto l703223; else goto l703226;
l703226: ;
pconverge_703225 = _681317;
goto l703224;
l703223: ;
pconverge_703225 = _701379;
goto l703224;
l703224: ;
converge_703225 = pconverge_703225;
pconverge_681586 = converge_703225;
goto l681585;
l681584: ;
pconverge_681586 = 0;
goto l681585;
l681585: ;
converge_681586 = pconverge_681586;
if (_681341) goto l681587; else goto l703217;
l703217: ;
if (_701368) goto l703218; else goto l703221;
l703221: ;
pconverge_703220 = _681340;
goto l703219;
l703218: ;
pconverge_703220 = _701347;
goto l703219;
l703219: ;
converge_703220 = pconverge_703220;
pconverge_681589 = converge_703220;
goto l681588;
l681587: ;
pconverge_681589 = 0;
goto l681588;
l681588: ;
converge_681589 = pconverge_681589;
if (_681346) goto l681590; else goto l703212;
l703212: ;
if (_701362) goto l703213; else goto l703216;
l703216: ;
pconverge_703215 = _681345;
goto l703214;
l703213: ;
pconverge_703215 = _701347;
goto l703214;
l703214: ;
converge_703215 = pconverge_703215;
pconverge_681592 = converge_703215;
goto l681591;
l681590: ;
pconverge_681592 = 0;
goto l681591;
l681591: ;
converge_681592 = pconverge_681592;
if (_681249) goto l681593; else goto l703207;
l703207: ;
if (_701356) goto l703208; else goto l703211;
l703211: ;
pconverge_703210 = _681248;
goto l703209;
l703208: ;
pconverge_703210 = _701347;
goto l703209;
l703209: ;
converge_703210 = pconverge_703210;
pconverge_681595 = converge_703210;
goto l681594;
l681593: ;
pconverge_681595 = 0;
goto l681594;
l681594: ;
converge_681595 = pconverge_681595;
if (_681254) goto l681596; else goto l703202;
l703202: ;
if (_701350) goto l703203; else goto l703206;
l703206: ;
pconverge_703205 = _681253;
goto l703204;
l703203: ;
pconverge_703205 = _701347;
goto l703204;
l703204: ;
converge_703205 = pconverge_703205;
pconverge_681598 = converge_703205;
goto l681597;
l681596: ;
pconverge_681598 = 0;
goto l681597;
l681597: ;
converge_681598 = pconverge_681598;
if (_681358) goto l681599; else goto l703197;
l703197: ;
if (_701343) goto l703198; else goto l703201;
l703201: ;
pconverge_703200 = _681357;
goto l703199;
l703198: ;
pconverge_703200 = _701347;
goto l703199;
l703199: ;
converge_703200 = pconverge_703200;
pconverge_681601 = converge_703200;
goto l681600;
l681599: ;
pconverge_681601 = 0;
goto l681600;
l681600: ;
converge_681601 = pconverge_681601;
if (_681511) goto l681602; else goto l703192;
l703192: ;
if (_701375) goto l703193; else goto l703196;
l703196: ;
pconverge_703195 = _681510;
goto l703194;
l703193: ;
pconverge_703195 = _701379;
goto l703194;
l703194: ;
converge_703195 = pconverge_703195;
pconverge_681604 = converge_703195;
goto l681603;
l681602: ;
pconverge_681604 = 0;
goto l681603;
l681603: ;
converge_681604 = pconverge_681604;
if (_681341) goto l681605; else goto l703187;
l703187: ;
if (_701368) goto l703188; else goto l703191;
l703191: ;
pconverge_703190 = _681340;
goto l703189;
l703188: ;
pconverge_703190 = _701347;
goto l703189;
l703189: ;
converge_703190 = pconverge_703190;
pconverge_681607 = converge_703190;
goto l681606;
l681605: ;
pconverge_681607 = 0;
goto l681606;
l681606: ;
converge_681607 = pconverge_681607;
if (_681346) goto l681608; else goto l703182;
l703182: ;
if (_701362) goto l703183; else goto l703186;
l703186: ;
pconverge_703185 = _681345;
goto l703184;
l703183: ;
pconverge_703185 = _701347;
goto l703184;
l703184: ;
converge_703185 = pconverge_703185;
pconverge_681610 = converge_703185;
goto l681609;
l681608: ;
pconverge_681610 = 0;
goto l681609;
l681609: ;
converge_681610 = pconverge_681610;
if (_681249) goto l681611; else goto l703177;
l703177: ;
if (_701356) goto l703178; else goto l703181;
l703181: ;
pconverge_703180 = _681248;
goto l703179;
l703178: ;
pconverge_703180 = _701347;
goto l703179;
l703179: ;
converge_703180 = pconverge_703180;
pconverge_681613 = converge_703180;
goto l681612;
l681611: ;
pconverge_681613 = 0;
goto l681612;
l681612: ;
converge_681613 = pconverge_681613;
if (_681254) goto l681614; else goto l703172;
l703172: ;
if (_701350) goto l703173; else goto l703176;
l703176: ;
pconverge_703175 = _681253;
goto l703174;
l703173: ;
pconverge_703175 = _701347;
goto l703174;
l703174: ;
converge_703175 = pconverge_703175;
pconverge_681616 = converge_703175;
goto l681615;
l681614: ;
pconverge_681616 = 0;
goto l681615;
l681615: ;
converge_681616 = pconverge_681616;
if (_681358) goto l681617; else goto l703167;
l703167: ;
if (_701343) goto l703168; else goto l703171;
l703171: ;
pconverge_703170 = _681357;
goto l703169;
l703168: ;
pconverge_703170 = _701347;
goto l703169;
l703169: ;
converge_703170 = pconverge_703170;
pconverge_681619 = converge_703170;
goto l681618;
l681617: ;
pconverge_681619 = 0;
goto l681618;
l681618: ;
converge_681619 = pconverge_681619;
if (_681228) goto l681620; else goto l703162;
l703162: ;
if (_701806) goto l703163; else goto l703166;
l703166: ;
pconverge_703165 = _681226;
goto l703164;
l703163: ;
pconverge_703165 = _701379;
goto l703164;
l703164: ;
converge_703165 = pconverge_703165;
pconverge_681622 = converge_703165;
goto l681621;
l681620: ;
pconverge_681622 = 0;
goto l681621;
l681621: ;
converge_681622 = pconverge_681622;
if (_681234) goto l681623; else goto l703157;
l703157: ;
if (_701528) goto l703158; else goto l703161;
l703161: ;
pconverge_703160 = _681233;
goto l703159;
l703158: ;
pconverge_703160 = _701347;
goto l703159;
l703159: ;
converge_703160 = pconverge_703160;
pconverge_681625 = converge_703160;
goto l681624;
l681623: ;
pconverge_681625 = 0;
goto l681624;
l681624: ;
converge_681625 = pconverge_681625;
if (_681240) goto l681626; else goto l703152;
l703152: ;
if (_701522) goto l703153; else goto l703156;
l703156: ;
pconverge_703155 = _681239;
goto l703154;
l703153: ;
pconverge_703155 = _701347;
goto l703154;
l703154: ;
converge_703155 = pconverge_703155;
pconverge_681628 = converge_703155;
goto l681627;
l681626: ;
pconverge_681628 = 0;
goto l681627;
l681627: ;
converge_681628 = pconverge_681628;
if (_681244) goto l681629; else goto l703147;
l703147: ;
if (_701516) goto l703148; else goto l703151;
l703151: ;
pconverge_703150 = xi_681232;
goto l703149;
l703148: ;
pconverge_703150 = _701347;
goto l703149;
l703149: ;
converge_703150 = pconverge_703150;
pconverge_681631 = converge_703150;
goto l681630;
l681629: ;
pconverge_681631 = 0;
goto l681630;
l681630: ;
converge_681631 = pconverge_681631;
if (_681249) goto l681632; else goto l703142;
l703142: ;
if (_701356) goto l703143; else goto l703146;
l703146: ;
pconverge_703145 = _681248;
goto l703144;
l703143: ;
pconverge_703145 = _701347;
goto l703144;
l703144: ;
converge_703145 = pconverge_703145;
pconverge_681634 = converge_703145;
goto l681633;
l681632: ;
pconverge_681634 = 0;
goto l681633;
l681633: ;
converge_681634 = pconverge_681634;
if (_681254) goto l681635; else goto l703137;
l703137: ;
if (_701350) goto l703138; else goto l703141;
l703141: ;
pconverge_703140 = _681253;
goto l703139;
l703138: ;
pconverge_703140 = _701347;
goto l703139;
l703139: ;
converge_703140 = pconverge_703140;
pconverge_681637 = converge_703140;
goto l681636;
l681635: ;
pconverge_681637 = 0;
goto l681636;
l681636: ;
converge_681637 = pconverge_681637;
if (_681259) goto l681638; else goto l703132;
l703132: ;
if (_701775) goto l703133; else goto l703136;
l703136: ;
pconverge_703135 = _681258;
goto l703134;
l703133: ;
pconverge_703135 = _701379;
goto l703134;
l703134: ;
converge_703135 = pconverge_703135;
pconverge_681640 = converge_703135;
goto l681639;
l681638: ;
pconverge_681640 = 0;
goto l681639;
l681639: ;
converge_681640 = pconverge_681640;
if (_681234) goto l681641; else goto l703127;
l703127: ;
if (_701528) goto l703128; else goto l703131;
l703131: ;
pconverge_703130 = _681233;
goto l703129;
l703128: ;
pconverge_703130 = _701347;
goto l703129;
l703129: ;
converge_703130 = pconverge_703130;
pconverge_681643 = converge_703130;
goto l681642;
l681641: ;
pconverge_681643 = 0;
goto l681642;
l681642: ;
converge_681643 = pconverge_681643;
if (_681240) goto l681644; else goto l703122;
l703122: ;
if (_701522) goto l703123; else goto l703126;
l703126: ;
pconverge_703125 = _681239;
goto l703124;
l703123: ;
pconverge_703125 = _701347;
goto l703124;
l703124: ;
converge_703125 = pconverge_703125;
pconverge_681646 = converge_703125;
goto l681645;
l681644: ;
pconverge_681646 = 0;
goto l681645;
l681645: ;
converge_681646 = pconverge_681646;
if (_681244) goto l681647; else goto l703117;
l703117: ;
if (_701516) goto l703118; else goto l703121;
l703121: ;
pconverge_703120 = xi_681232;
goto l703119;
l703118: ;
pconverge_703120 = _701347;
goto l703119;
l703119: ;
converge_703120 = pconverge_703120;
pconverge_681649 = converge_703120;
goto l681648;
l681647: ;
pconverge_681649 = 0;
goto l681648;
l681648: ;
converge_681649 = pconverge_681649;
if (_681249) goto l681650; else goto l703112;
l703112: ;
if (_701356) goto l703113; else goto l703116;
l703116: ;
pconverge_703115 = _681248;
goto l703114;
l703113: ;
pconverge_703115 = _701347;
goto l703114;
l703114: ;
converge_703115 = pconverge_703115;
pconverge_681652 = converge_703115;
goto l681651;
l681650: ;
pconverge_681652 = 0;
goto l681651;
l681651: ;
converge_681652 = pconverge_681652;
if (_681254) goto l681653; else goto l703107;
l703107: ;
if (_701350) goto l703108; else goto l703111;
l703111: ;
pconverge_703110 = _681253;
goto l703109;
l703108: ;
pconverge_703110 = _701347;
goto l703109;
l703109: ;
converge_703110 = pconverge_703110;
pconverge_681655 = converge_703110;
goto l681654;
l681653: ;
pconverge_681655 = 0;
goto l681654;
l681654: ;
converge_681655 = pconverge_681655;
if (_681278) goto l681656; else goto l703102;
l703102: ;
if (_701744) goto l703103; else goto l703106;
l703106: ;
pconverge_703105 = yi_681224;
goto l703104;
l703103: ;
pconverge_703105 = _701379;
goto l703104;
l703104: ;
converge_703105 = pconverge_703105;
pconverge_681658 = converge_703105;
goto l681657;
l681656: ;
pconverge_681658 = 0;
goto l681657;
l681657: ;
converge_681658 = pconverge_681658;
if (_681234) goto l681659; else goto l703097;
l703097: ;
if (_701528) goto l703098; else goto l703101;
l703101: ;
pconverge_703100 = _681233;
goto l703099;
l703098: ;
pconverge_703100 = _701347;
goto l703099;
l703099: ;
converge_703100 = pconverge_703100;
pconverge_681661 = converge_703100;
goto l681660;
l681659: ;
pconverge_681661 = 0;
goto l681660;
l681660: ;
converge_681661 = pconverge_681661;
if (_681240) goto l681662; else goto l703092;
l703092: ;
if (_701522) goto l703093; else goto l703096;
l703096: ;
pconverge_703095 = _681239;
goto l703094;
l703093: ;
pconverge_703095 = _701347;
goto l703094;
l703094: ;
converge_703095 = pconverge_703095;
pconverge_681664 = converge_703095;
goto l681663;
l681662: ;
pconverge_681664 = 0;
goto l681663;
l681663: ;
converge_681664 = pconverge_681664;
if (_681244) goto l681665; else goto l703087;
l703087: ;
if (_701516) goto l703088; else goto l703091;
l703091: ;
pconverge_703090 = xi_681232;
goto l703089;
l703088: ;
pconverge_703090 = _701347;
goto l703089;
l703089: ;
converge_703090 = pconverge_703090;
pconverge_681667 = converge_703090;
goto l681666;
l681665: ;
pconverge_681667 = 0;
goto l681666;
l681666: ;
converge_681667 = pconverge_681667;
if (_681249) goto l681668; else goto l703082;
l703082: ;
if (_701356) goto l703083; else goto l703086;
l703086: ;
pconverge_703085 = _681248;
goto l703084;
l703083: ;
pconverge_703085 = _701347;
goto l703084;
l703084: ;
converge_703085 = pconverge_703085;
pconverge_681670 = converge_703085;
goto l681669;
l681668: ;
pconverge_681670 = 0;
goto l681669;
l681669: ;
converge_681670 = pconverge_681670;
if (_681254) goto l681671; else goto l703077;
l703077: ;
if (_701350) goto l703078; else goto l703081;
l703081: ;
pconverge_703080 = _681253;
goto l703079;
l703078: ;
pconverge_703080 = _701347;
goto l703079;
l703079: ;
converge_703080 = pconverge_703080;
pconverge_681673 = converge_703080;
goto l681672;
l681671: ;
pconverge_681673 = 0;
goto l681672;
l681672: ;
converge_681673 = pconverge_681673;
if (_681298) goto l681674; else goto l703072;
l703072: ;
if (_701438) goto l703073; else goto l703076;
l703076: ;
pconverge_703075 = _681297;
goto l703074;
l703073: ;
pconverge_703075 = _701379;
goto l703074;
l703074: ;
converge_703075 = pconverge_703075;
pconverge_681676 = converge_703075;
goto l681675;
l681674: ;
pconverge_681676 = 0;
goto l681675;
l681675: ;
converge_681676 = pconverge_681676;
if (_681234) goto l681677; else goto l703067;
l703067: ;
if (_701528) goto l703068; else goto l703071;
l703071: ;
pconverge_703070 = _681233;
goto l703069;
l703068: ;
pconverge_703070 = _701347;
goto l703069;
l703069: ;
converge_703070 = pconverge_703070;
pconverge_681679 = converge_703070;
goto l681678;
l681677: ;
pconverge_681679 = 0;
goto l681678;
l681678: ;
converge_681679 = pconverge_681679;
if (_681240) goto l681680; else goto l703062;
l703062: ;
if (_701522) goto l703063; else goto l703066;
l703066: ;
pconverge_703065 = _681239;
goto l703064;
l703063: ;
pconverge_703065 = _701347;
goto l703064;
l703064: ;
converge_703065 = pconverge_703065;
pconverge_681682 = converge_703065;
goto l681681;
l681680: ;
pconverge_681682 = 0;
goto l681681;
l681681: ;
converge_681682 = pconverge_681682;
if (_681244) goto l681683; else goto l703057;
l703057: ;
if (_701516) goto l703058; else goto l703061;
l703061: ;
pconverge_703060 = xi_681232;
goto l703059;
l703058: ;
pconverge_703060 = _701347;
goto l703059;
l703059: ;
converge_703060 = pconverge_703060;
pconverge_681685 = converge_703060;
goto l681684;
l681683: ;
pconverge_681685 = 0;
goto l681684;
l681684: ;
converge_681685 = pconverge_681685;
if (_681249) goto l681686; else goto l703052;
l703052: ;
if (_701356) goto l703053; else goto l703056;
l703056: ;
pconverge_703055 = _681248;
goto l703054;
l703053: ;
pconverge_703055 = _701347;
goto l703054;
l703054: ;
converge_703055 = pconverge_703055;
pconverge_681688 = converge_703055;
goto l681687;
l681686: ;
pconverge_681688 = 0;
goto l681687;
l681687: ;
converge_681688 = pconverge_681688;
if (_681254) goto l681689; else goto l703047;
l703047: ;
if (_701350) goto l703048; else goto l703051;
l703051: ;
pconverge_703050 = _681253;
goto l703049;
l703048: ;
pconverge_703050 = _701347;
goto l703049;
l703049: ;
converge_703050 = pconverge_703050;
pconverge_681691 = converge_703050;
goto l681690;
l681689: ;
pconverge_681691 = 0;
goto l681690;
l681690: ;
converge_681691 = pconverge_681691;
if (_681318) goto l681692; else goto l703042;
l703042: ;
if (_701407) goto l703043; else goto l703046;
l703046: ;
pconverge_703045 = _681317;
goto l703044;
l703043: ;
pconverge_703045 = _701379;
goto l703044;
l703044: ;
converge_703045 = pconverge_703045;
pconverge_681694 = converge_703045;
goto l681693;
l681692: ;
pconverge_681694 = 0;
goto l681693;
l681693: ;
converge_681694 = pconverge_681694;
if (_681234) goto l681695; else goto l703037;
l703037: ;
if (_701528) goto l703038; else goto l703041;
l703041: ;
pconverge_703040 = _681233;
goto l703039;
l703038: ;
pconverge_703040 = _701347;
goto l703039;
l703039: ;
converge_703040 = pconverge_703040;
pconverge_681697 = converge_703040;
goto l681696;
l681695: ;
pconverge_681697 = 0;
goto l681696;
l681696: ;
converge_681697 = pconverge_681697;
if (_681240) goto l681698; else goto l703032;
l703032: ;
if (_701522) goto l703033; else goto l703036;
l703036: ;
pconverge_703035 = _681239;
goto l703034;
l703033: ;
pconverge_703035 = _701347;
goto l703034;
l703034: ;
converge_703035 = pconverge_703035;
pconverge_681700 = converge_703035;
goto l681699;
l681698: ;
pconverge_681700 = 0;
goto l681699;
l681699: ;
converge_681700 = pconverge_681700;
if (_681244) goto l681701; else goto l703027;
l703027: ;
if (_701516) goto l703028; else goto l703031;
l703031: ;
pconverge_703030 = xi_681232;
goto l703029;
l703028: ;
pconverge_703030 = _701347;
goto l703029;
l703029: ;
converge_703030 = pconverge_703030;
pconverge_681703 = converge_703030;
goto l681702;
l681701: ;
pconverge_681703 = 0;
goto l681702;
l681702: ;
converge_681703 = pconverge_681703;
if (_681249) goto l681704; else goto l703022;
l703022: ;
if (_701356) goto l703023; else goto l703026;
l703026: ;
pconverge_703025 = _681248;
goto l703024;
l703023: ;
pconverge_703025 = _701347;
goto l703024;
l703024: ;
converge_703025 = pconverge_703025;
pconverge_681706 = converge_703025;
goto l681705;
l681704: ;
pconverge_681706 = 0;
goto l681705;
l681705: ;
converge_681706 = pconverge_681706;
if (_681254) goto l681707; else goto l703017;
l703017: ;
if (_701350) goto l703018; else goto l703021;
l703021: ;
pconverge_703020 = _681253;
goto l703019;
l703018: ;
pconverge_703020 = _701347;
goto l703019;
l703019: ;
converge_703020 = pconverge_703020;
pconverge_681709 = converge_703020;
goto l681708;
l681707: ;
pconverge_681709 = 0;
goto l681708;
l681708: ;
converge_681709 = pconverge_681709;
if (_681228) goto l681710; else goto l703012;
l703012: ;
if (_701806) goto l703013; else goto l703016;
l703016: ;
pconverge_703015 = _681226;
goto l703014;
l703013: ;
pconverge_703015 = _701379;
goto l703014;
l703014: ;
converge_703015 = pconverge_703015;
pconverge_681712 = converge_703015;
goto l681711;
l681710: ;
pconverge_681712 = 0;
goto l681711;
l681711: ;
converge_681712 = pconverge_681712;
if (_681341) goto l681713; else goto l703007;
l703007: ;
if (_701368) goto l703008; else goto l703011;
l703011: ;
pconverge_703010 = _681340;
goto l703009;
l703008: ;
pconverge_703010 = _701347;
goto l703009;
l703009: ;
converge_703010 = pconverge_703010;
pconverge_681715 = converge_703010;
goto l681714;
l681713: ;
pconverge_681715 = 0;
goto l681714;
l681714: ;
converge_681715 = pconverge_681715;
if (_681346) goto l681716; else goto l703002;
l703002: ;
if (_701362) goto l703003; else goto l703006;
l703006: ;
pconverge_703005 = _681345;
goto l703004;
l703003: ;
pconverge_703005 = _701347;
goto l703004;
l703004: ;
converge_703005 = pconverge_703005;
pconverge_681718 = converge_703005;
goto l681717;
l681716: ;
pconverge_681718 = 0;
goto l681717;
l681717: ;
converge_681718 = pconverge_681718;
if (_681249) goto l681719; else goto l702997;
l702997: ;
if (_701356) goto l702998; else goto l703001;
l703001: ;
pconverge_703000 = _681248;
goto l702999;
l702998: ;
pconverge_703000 = _701347;
goto l702999;
l702999: ;
converge_703000 = pconverge_703000;
pconverge_681721 = converge_703000;
goto l681720;
l681719: ;
pconverge_681721 = 0;
goto l681720;
l681720: ;
converge_681721 = pconverge_681721;
if (_681254) goto l681722; else goto l702992;
l702992: ;
if (_701350) goto l702993; else goto l702996;
l702996: ;
pconverge_702995 = _681253;
goto l702994;
l702993: ;
pconverge_702995 = _701347;
goto l702994;
l702994: ;
converge_702995 = pconverge_702995;
pconverge_681724 = converge_702995;
goto l681723;
l681722: ;
pconverge_681724 = 0;
goto l681723;
l681723: ;
converge_681724 = pconverge_681724;
if (_681358) goto l681725; else goto l702987;
l702987: ;
if (_701343) goto l702988; else goto l702991;
l702991: ;
pconverge_702990 = _681357;
goto l702989;
l702988: ;
pconverge_702990 = _701347;
goto l702989;
l702989: ;
converge_702990 = pconverge_702990;
pconverge_681727 = converge_702990;
goto l681726;
l681725: ;
pconverge_681727 = 0;
goto l681726;
l681726: ;
converge_681727 = pconverge_681727;
if (_681259) goto l681728; else goto l702982;
l702982: ;
if (_701775) goto l702983; else goto l702986;
l702986: ;
pconverge_702985 = _681258;
goto l702984;
l702983: ;
pconverge_702985 = _701379;
goto l702984;
l702984: ;
converge_702985 = pconverge_702985;
pconverge_681730 = converge_702985;
goto l681729;
l681728: ;
pconverge_681730 = 0;
goto l681729;
l681729: ;
converge_681730 = pconverge_681730;
if (_681341) goto l681731; else goto l702977;
l702977: ;
if (_701368) goto l702978; else goto l702981;
l702981: ;
pconverge_702980 = _681340;
goto l702979;
l702978: ;
pconverge_702980 = _701347;
goto l702979;
l702979: ;
converge_702980 = pconverge_702980;
pconverge_681733 = converge_702980;
goto l681732;
l681731: ;
pconverge_681733 = 0;
goto l681732;
l681732: ;
converge_681733 = pconverge_681733;
if (_681346) goto l681734; else goto l702972;
l702972: ;
if (_701362) goto l702973; else goto l702976;
l702976: ;
pconverge_702975 = _681345;
goto l702974;
l702973: ;
pconverge_702975 = _701347;
goto l702974;
l702974: ;
converge_702975 = pconverge_702975;
pconverge_681736 = converge_702975;
goto l681735;
l681734: ;
pconverge_681736 = 0;
goto l681735;
l681735: ;
converge_681736 = pconverge_681736;
if (_681249) goto l681737; else goto l702967;
l702967: ;
if (_701356) goto l702968; else goto l702971;
l702971: ;
pconverge_702970 = _681248;
goto l702969;
l702968: ;
pconverge_702970 = _701347;
goto l702969;
l702969: ;
converge_702970 = pconverge_702970;
pconverge_681739 = converge_702970;
goto l681738;
l681737: ;
pconverge_681739 = 0;
goto l681738;
l681738: ;
converge_681739 = pconverge_681739;
if (_681254) goto l681740; else goto l702962;
l702962: ;
if (_701350) goto l702963; else goto l702966;
l702966: ;
pconverge_702965 = _681253;
goto l702964;
l702963: ;
pconverge_702965 = _701347;
goto l702964;
l702964: ;
converge_702965 = pconverge_702965;
pconverge_681742 = converge_702965;
goto l681741;
l681740: ;
pconverge_681742 = 0;
goto l681741;
l681741: ;
converge_681742 = pconverge_681742;
if (_681358) goto l681743; else goto l702957;
l702957: ;
if (_701343) goto l702958; else goto l702961;
l702961: ;
pconverge_702960 = _681357;
goto l702959;
l702958: ;
pconverge_702960 = _701347;
goto l702959;
l702959: ;
converge_702960 = pconverge_702960;
pconverge_681745 = converge_702960;
goto l681744;
l681743: ;
pconverge_681745 = 0;
goto l681744;
l681744: ;
converge_681745 = pconverge_681745;
if (_681278) goto l681746; else goto l702952;
l702952: ;
if (_701744) goto l702953; else goto l702956;
l702956: ;
pconverge_702955 = yi_681224;
goto l702954;
l702953: ;
pconverge_702955 = _701379;
goto l702954;
l702954: ;
converge_702955 = pconverge_702955;
pconverge_681748 = converge_702955;
goto l681747;
l681746: ;
pconverge_681748 = 0;
goto l681747;
l681747: ;
converge_681748 = pconverge_681748;
if (_681341) goto l681749; else goto l702947;
l702947: ;
if (_701368) goto l702948; else goto l702951;
l702951: ;
pconverge_702950 = _681340;
goto l702949;
l702948: ;
pconverge_702950 = _701347;
goto l702949;
l702949: ;
converge_702950 = pconverge_702950;
pconverge_681751 = converge_702950;
goto l681750;
l681749: ;
pconverge_681751 = 0;
goto l681750;
l681750: ;
converge_681751 = pconverge_681751;
if (_681346) goto l681752; else goto l702942;
l702942: ;
if (_701362) goto l702943; else goto l702946;
l702946: ;
pconverge_702945 = _681345;
goto l702944;
l702943: ;
pconverge_702945 = _701347;
goto l702944;
l702944: ;
converge_702945 = pconverge_702945;
pconverge_681754 = converge_702945;
goto l681753;
l681752: ;
pconverge_681754 = 0;
goto l681753;
l681753: ;
converge_681754 = pconverge_681754;
if (_681249) goto l681755; else goto l702937;
l702937: ;
if (_701356) goto l702938; else goto l702941;
l702941: ;
pconverge_702940 = _681248;
goto l702939;
l702938: ;
pconverge_702940 = _701347;
goto l702939;
l702939: ;
converge_702940 = pconverge_702940;
pconverge_681757 = converge_702940;
goto l681756;
l681755: ;
pconverge_681757 = 0;
goto l681756;
l681756: ;
converge_681757 = pconverge_681757;
if (_681254) goto l681758; else goto l702932;
l702932: ;
if (_701350) goto l702933; else goto l702936;
l702936: ;
pconverge_702935 = _681253;
goto l702934;
l702933: ;
pconverge_702935 = _701347;
goto l702934;
l702934: ;
converge_702935 = pconverge_702935;
pconverge_681760 = converge_702935;
goto l681759;
l681758: ;
pconverge_681760 = 0;
goto l681759;
l681759: ;
converge_681760 = pconverge_681760;
if (_681358) goto l681761; else goto l702927;
l702927: ;
if (_701343) goto l702928; else goto l702931;
l702931: ;
pconverge_702930 = _681357;
goto l702929;
l702928: ;
pconverge_702930 = _701347;
goto l702929;
l702929: ;
converge_702930 = pconverge_702930;
pconverge_681763 = converge_702930;
goto l681762;
l681761: ;
pconverge_681763 = 0;
goto l681762;
l681762: ;
converge_681763 = pconverge_681763;
if (_681298) goto l681764; else goto l702922;
l702922: ;
if (_701438) goto l702923; else goto l702926;
l702926: ;
pconverge_702925 = _681297;
goto l702924;
l702923: ;
pconverge_702925 = _701379;
goto l702924;
l702924: ;
converge_702925 = pconverge_702925;
pconverge_681766 = converge_702925;
goto l681765;
l681764: ;
pconverge_681766 = 0;
goto l681765;
l681765: ;
converge_681766 = pconverge_681766;
if (_681341) goto l681767; else goto l702917;
l702917: ;
if (_701368) goto l702918; else goto l702921;
l702921: ;
pconverge_702920 = _681340;
goto l702919;
l702918: ;
pconverge_702920 = _701347;
goto l702919;
l702919: ;
converge_702920 = pconverge_702920;
pconverge_681769 = converge_702920;
goto l681768;
l681767: ;
pconverge_681769 = 0;
goto l681768;
l681768: ;
converge_681769 = pconverge_681769;
if (_681346) goto l681770; else goto l702912;
l702912: ;
if (_701362) goto l702913; else goto l702916;
l702916: ;
pconverge_702915 = _681345;
goto l702914;
l702913: ;
pconverge_702915 = _701347;
goto l702914;
l702914: ;
converge_702915 = pconverge_702915;
pconverge_681772 = converge_702915;
goto l681771;
l681770: ;
pconverge_681772 = 0;
goto l681771;
l681771: ;
converge_681772 = pconverge_681772;
if (_681249) goto l681773; else goto l702907;
l702907: ;
if (_701356) goto l702908; else goto l702911;
l702911: ;
pconverge_702910 = _681248;
goto l702909;
l702908: ;
pconverge_702910 = _701347;
goto l702909;
l702909: ;
converge_702910 = pconverge_702910;
pconverge_681775 = converge_702910;
goto l681774;
l681773: ;
pconverge_681775 = 0;
goto l681774;
l681774: ;
converge_681775 = pconverge_681775;
if (_681254) goto l681776; else goto l702902;
l702902: ;
if (_701350) goto l702903; else goto l702906;
l702906: ;
pconverge_702905 = _681253;
goto l702904;
l702903: ;
pconverge_702905 = _701347;
goto l702904;
l702904: ;
converge_702905 = pconverge_702905;
pconverge_681778 = converge_702905;
goto l681777;
l681776: ;
pconverge_681778 = 0;
goto l681777;
l681777: ;
converge_681778 = pconverge_681778;
if (_681358) goto l681779; else goto l702897;
l702897: ;
if (_701343) goto l702898; else goto l702901;
l702901: ;
pconverge_702900 = _681357;
goto l702899;
l702898: ;
pconverge_702900 = _701347;
goto l702899;
l702899: ;
converge_702900 = pconverge_702900;
pconverge_681781 = converge_702900;
goto l681780;
l681779: ;
pconverge_681781 = 0;
goto l681780;
l681780: ;
converge_681781 = pconverge_681781;
if (_681318) goto l681782; else goto l702892;
l702892: ;
if (_701407) goto l702893; else goto l702896;
l702896: ;
pconverge_702895 = _681317;
goto l702894;
l702893: ;
pconverge_702895 = _701379;
goto l702894;
l702894: ;
converge_702895 = pconverge_702895;
pconverge_681784 = converge_702895;
goto l681783;
l681782: ;
pconverge_681784 = 0;
goto l681783;
l681783: ;
converge_681784 = pconverge_681784;
if (_681341) goto l681785; else goto l702887;
l702887: ;
if (_701368) goto l702888; else goto l702891;
l702891: ;
pconverge_702890 = _681340;
goto l702889;
l702888: ;
pconverge_702890 = _701347;
goto l702889;
l702889: ;
converge_702890 = pconverge_702890;
pconverge_681787 = converge_702890;
goto l681786;
l681785: ;
pconverge_681787 = 0;
goto l681786;
l681786: ;
converge_681787 = pconverge_681787;
if (_681346) goto l681788; else goto l702882;
l702882: ;
if (_701362) goto l702883; else goto l702886;
l702886: ;
pconverge_702885 = _681345;
goto l702884;
l702883: ;
pconverge_702885 = _701347;
goto l702884;
l702884: ;
converge_702885 = pconverge_702885;
pconverge_681790 = converge_702885;
goto l681789;
l681788: ;
pconverge_681790 = 0;
goto l681789;
l681789: ;
converge_681790 = pconverge_681790;
if (_681249) goto l681791; else goto l702877;
l702877: ;
if (_701356) goto l702878; else goto l702881;
l702881: ;
pconverge_702880 = _681248;
goto l702879;
l702878: ;
pconverge_702880 = _701347;
goto l702879;
l702879: ;
converge_702880 = pconverge_702880;
pconverge_681793 = converge_702880;
goto l681792;
l681791: ;
pconverge_681793 = 0;
goto l681792;
l681792: ;
converge_681793 = pconverge_681793;
if (_681254) goto l681794; else goto l702872;
l702872: ;
if (_701350) goto l702873; else goto l702876;
l702876: ;
pconverge_702875 = _681253;
goto l702874;
l702873: ;
pconverge_702875 = _701347;
goto l702874;
l702874: ;
converge_702875 = pconverge_702875;
pconverge_681796 = converge_702875;
goto l681795;
l681794: ;
pconverge_681796 = 0;
goto l681795;
l681795: ;
converge_681796 = pconverge_681796;
if (_681358) goto l681797; else goto l702867;
l702867: ;
if (_701343) goto l702868; else goto l702871;
l702871: ;
pconverge_702870 = _681357;
goto l702869;
l702868: ;
pconverge_702870 = _701347;
goto l702869;
l702869: ;
converge_702870 = pconverge_702870;
pconverge_681799 = converge_702870;
goto l681798;
l681797: ;
pconverge_681799 = 0;
goto l681798;
l681798: ;
converge_681799 = pconverge_681799;
if (_681435) goto l681800; else goto l702862;
l702862: ;
if (_701500) goto l702863; else goto l702866;
l702866: ;
pconverge_702865 = _681434;
goto l702864;
l702863: ;
pconverge_702865 = _701379;
goto l702864;
l702864: ;
converge_702865 = pconverge_702865;
pconverge_681802 = converge_702865;
goto l681801;
l681800: ;
pconverge_681802 = 0;
goto l681801;
l681801: ;
converge_681802 = pconverge_681802;
if (_681234) goto l681803; else goto l702857;
l702857: ;
if (_701528) goto l702858; else goto l702861;
l702861: ;
pconverge_702860 = _681233;
goto l702859;
l702858: ;
pconverge_702860 = _701347;
goto l702859;
l702859: ;
converge_702860 = pconverge_702860;
pconverge_681805 = converge_702860;
goto l681804;
l681803: ;
pconverge_681805 = 0;
goto l681804;
l681804: ;
converge_681805 = pconverge_681805;
if (_681240) goto l681806; else goto l702852;
l702852: ;
if (_701522) goto l702853; else goto l702856;
l702856: ;
pconverge_702855 = _681239;
goto l702854;
l702853: ;
pconverge_702855 = _701347;
goto l702854;
l702854: ;
converge_702855 = pconverge_702855;
pconverge_681808 = converge_702855;
goto l681807;
l681806: ;
pconverge_681808 = 0;
goto l681807;
l681807: ;
converge_681808 = pconverge_681808;
if (_681244) goto l681809; else goto l702847;
l702847: ;
if (_701516) goto l702848; else goto l702851;
l702851: ;
pconverge_702850 = xi_681232;
goto l702849;
l702848: ;
pconverge_702850 = _701347;
goto l702849;
l702849: ;
converge_702850 = pconverge_702850;
pconverge_681811 = converge_702850;
goto l681810;
l681809: ;
pconverge_681811 = 0;
goto l681810;
l681810: ;
converge_681811 = pconverge_681811;
if (_681249) goto l681812; else goto l702842;
l702842: ;
if (_701356) goto l702843; else goto l702846;
l702846: ;
pconverge_702845 = _681248;
goto l702844;
l702843: ;
pconverge_702845 = _701347;
goto l702844;
l702844: ;
converge_702845 = pconverge_702845;
pconverge_681814 = converge_702845;
goto l681813;
l681812: ;
pconverge_681814 = 0;
goto l681813;
l681813: ;
converge_681814 = pconverge_681814;
if (_681254) goto l681815; else goto l702837;
l702837: ;
if (_701350) goto l702838; else goto l702841;
l702841: ;
pconverge_702840 = _681253;
goto l702839;
l702838: ;
pconverge_702840 = _701347;
goto l702839;
l702839: ;
converge_702840 = pconverge_702840;
pconverge_681817 = converge_702840;
goto l681816;
l681815: ;
pconverge_681817 = 0;
goto l681816;
l681816: ;
converge_681817 = pconverge_681817;
if (_681455) goto l681818; else goto l702832;
l702832: ;
if (_701469) goto l702833; else goto l702836;
l702836: ;
pconverge_702835 = _681454;
goto l702834;
l702833: ;
pconverge_702835 = _701379;
goto l702834;
l702834: ;
converge_702835 = pconverge_702835;
pconverge_681820 = converge_702835;
goto l681819;
l681818: ;
pconverge_681820 = 0;
goto l681819;
l681819: ;
converge_681820 = pconverge_681820;
if (_681234) goto l681821; else goto l702827;
l702827: ;
if (_701528) goto l702828; else goto l702831;
l702831: ;
pconverge_702830 = _681233;
goto l702829;
l702828: ;
pconverge_702830 = _701347;
goto l702829;
l702829: ;
converge_702830 = pconverge_702830;
pconverge_681823 = converge_702830;
goto l681822;
l681821: ;
pconverge_681823 = 0;
goto l681822;
l681822: ;
converge_681823 = pconverge_681823;
if (_681240) goto l681824; else goto l702822;
l702822: ;
if (_701522) goto l702823; else goto l702826;
l702826: ;
pconverge_702825 = _681239;
goto l702824;
l702823: ;
pconverge_702825 = _701347;
goto l702824;
l702824: ;
converge_702825 = pconverge_702825;
pconverge_681826 = converge_702825;
goto l681825;
l681824: ;
pconverge_681826 = 0;
goto l681825;
l681825: ;
converge_681826 = pconverge_681826;
if (_681244) goto l681827; else goto l702817;
l702817: ;
if (_701516) goto l702818; else goto l702821;
l702821: ;
pconverge_702820 = xi_681232;
goto l702819;
l702818: ;
pconverge_702820 = _701347;
goto l702819;
l702819: ;
converge_702820 = pconverge_702820;
pconverge_681829 = converge_702820;
goto l681828;
l681827: ;
pconverge_681829 = 0;
goto l681828;
l681828: ;
converge_681829 = pconverge_681829;
if (_681249) goto l681830; else goto l702812;
l702812: ;
if (_701356) goto l702813; else goto l702816;
l702816: ;
pconverge_702815 = _681248;
goto l702814;
l702813: ;
pconverge_702815 = _701347;
goto l702814;
l702814: ;
converge_702815 = pconverge_702815;
pconverge_681832 = converge_702815;
goto l681831;
l681830: ;
pconverge_681832 = 0;
goto l681831;
l681831: ;
converge_681832 = pconverge_681832;
if (_681254) goto l681833; else goto l702807;
l702807: ;
if (_701350) goto l702808; else goto l702811;
l702811: ;
pconverge_702810 = _681253;
goto l702809;
l702808: ;
pconverge_702810 = _701347;
goto l702809;
l702809: ;
converge_702810 = pconverge_702810;
pconverge_681835 = converge_702810;
goto l681834;
l681833: ;
pconverge_681835 = 0;
goto l681834;
l681834: ;
converge_681835 = pconverge_681835;
if (_681298) goto l681836; else goto l702802;
l702802: ;
if (_701438) goto l702803; else goto l702806;
l702806: ;
pconverge_702805 = _681297;
goto l702804;
l702803: ;
pconverge_702805 = _701379;
goto l702804;
l702804: ;
converge_702805 = pconverge_702805;
pconverge_681838 = converge_702805;
goto l681837;
l681836: ;
pconverge_681838 = 0;
goto l681837;
l681837: ;
converge_681838 = pconverge_681838;
if (_681234) goto l681839; else goto l702797;
l702797: ;
if (_701528) goto l702798; else goto l702801;
l702801: ;
pconverge_702800 = _681233;
goto l702799;
l702798: ;
pconverge_702800 = _701347;
goto l702799;
l702799: ;
converge_702800 = pconverge_702800;
pconverge_681841 = converge_702800;
goto l681840;
l681839: ;
pconverge_681841 = 0;
goto l681840;
l681840: ;
converge_681841 = pconverge_681841;
if (_681240) goto l681842; else goto l702792;
l702792: ;
if (_701522) goto l702793; else goto l702796;
l702796: ;
pconverge_702795 = _681239;
goto l702794;
l702793: ;
pconverge_702795 = _701347;
goto l702794;
l702794: ;
converge_702795 = pconverge_702795;
pconverge_681844 = converge_702795;
goto l681843;
l681842: ;
pconverge_681844 = 0;
goto l681843;
l681843: ;
converge_681844 = pconverge_681844;
if (_681244) goto l681845; else goto l702787;
l702787: ;
if (_701516) goto l702788; else goto l702791;
l702791: ;
pconverge_702790 = xi_681232;
goto l702789;
l702788: ;
pconverge_702790 = _701347;
goto l702789;
l702789: ;
converge_702790 = pconverge_702790;
pconverge_681847 = converge_702790;
goto l681846;
l681845: ;
pconverge_681847 = 0;
goto l681846;
l681846: ;
converge_681847 = pconverge_681847;
if (_681249) goto l681848; else goto l702782;
l702782: ;
if (_701356) goto l702783; else goto l702786;
l702786: ;
pconverge_702785 = _681248;
goto l702784;
l702783: ;
pconverge_702785 = _701347;
goto l702784;
l702784: ;
converge_702785 = pconverge_702785;
pconverge_681850 = converge_702785;
goto l681849;
l681848: ;
pconverge_681850 = 0;
goto l681849;
l681849: ;
converge_681850 = pconverge_681850;
if (_681254) goto l681851; else goto l702777;
l702777: ;
if (_701350) goto l702778; else goto l702781;
l702781: ;
pconverge_702780 = _681253;
goto l702779;
l702778: ;
pconverge_702780 = _701347;
goto l702779;
l702779: ;
converge_702780 = pconverge_702780;
pconverge_681853 = converge_702780;
goto l681852;
l681851: ;
pconverge_681853 = 0;
goto l681852;
l681852: ;
converge_681853 = pconverge_681853;
if (_681318) goto l681854; else goto l702772;
l702772: ;
if (_701407) goto l702773; else goto l702776;
l702776: ;
pconverge_702775 = _681317;
goto l702774;
l702773: ;
pconverge_702775 = _701379;
goto l702774;
l702774: ;
converge_702775 = pconverge_702775;
pconverge_681856 = converge_702775;
goto l681855;
l681854: ;
pconverge_681856 = 0;
goto l681855;
l681855: ;
converge_681856 = pconverge_681856;
if (_681234) goto l681857; else goto l702767;
l702767: ;
if (_701528) goto l702768; else goto l702771;
l702771: ;
pconverge_702770 = _681233;
goto l702769;
l702768: ;
pconverge_702770 = _701347;
goto l702769;
l702769: ;
converge_702770 = pconverge_702770;
pconverge_681859 = converge_702770;
goto l681858;
l681857: ;
pconverge_681859 = 0;
goto l681858;
l681858: ;
converge_681859 = pconverge_681859;
if (_681240) goto l681860; else goto l702762;
l702762: ;
if (_701522) goto l702763; else goto l702766;
l702766: ;
pconverge_702765 = _681239;
goto l702764;
l702763: ;
pconverge_702765 = _701347;
goto l702764;
l702764: ;
converge_702765 = pconverge_702765;
pconverge_681862 = converge_702765;
goto l681861;
l681860: ;
pconverge_681862 = 0;
goto l681861;
l681861: ;
converge_681862 = pconverge_681862;
if (_681244) goto l681863; else goto l702757;
l702757: ;
if (_701516) goto l702758; else goto l702761;
l702761: ;
pconverge_702760 = xi_681232;
goto l702759;
l702758: ;
pconverge_702760 = _701347;
goto l702759;
l702759: ;
converge_702760 = pconverge_702760;
pconverge_681865 = converge_702760;
goto l681864;
l681863: ;
pconverge_681865 = 0;
goto l681864;
l681864: ;
converge_681865 = pconverge_681865;
if (_681249) goto l681866; else goto l702752;
l702752: ;
if (_701356) goto l702753; else goto l702756;
l702756: ;
pconverge_702755 = _681248;
goto l702754;
l702753: ;
pconverge_702755 = _701347;
goto l702754;
l702754: ;
converge_702755 = pconverge_702755;
pconverge_681868 = converge_702755;
goto l681867;
l681866: ;
pconverge_681868 = 0;
goto l681867;
l681867: ;
converge_681868 = pconverge_681868;
if (_681254) goto l681869; else goto l702747;
l702747: ;
if (_701350) goto l702748; else goto l702751;
l702751: ;
pconverge_702750 = _681253;
goto l702749;
l702748: ;
pconverge_702750 = _701347;
goto l702749;
l702749: ;
converge_702750 = pconverge_702750;
pconverge_681871 = converge_702750;
goto l681870;
l681869: ;
pconverge_681871 = 0;
goto l681870;
l681870: ;
converge_681871 = pconverge_681871;
if (_681511) goto l681872; else goto l702742;
l702742: ;
if (_701375) goto l702743; else goto l702746;
l702746: ;
pconverge_702745 = _681510;
goto l702744;
l702743: ;
pconverge_702745 = _701379;
goto l702744;
l702744: ;
converge_702745 = pconverge_702745;
pconverge_681874 = converge_702745;
goto l681873;
l681872: ;
pconverge_681874 = 0;
goto l681873;
l681873: ;
converge_681874 = pconverge_681874;
if (_681234) goto l681875; else goto l702737;
l702737: ;
if (_701528) goto l702738; else goto l702741;
l702741: ;
pconverge_702740 = _681233;
goto l702739;
l702738: ;
pconverge_702740 = _701347;
goto l702739;
l702739: ;
converge_702740 = pconverge_702740;
pconverge_681877 = converge_702740;
goto l681876;
l681875: ;
pconverge_681877 = 0;
goto l681876;
l681876: ;
converge_681877 = pconverge_681877;
if (_681240) goto l681878; else goto l702732;
l702732: ;
if (_701522) goto l702733; else goto l702736;
l702736: ;
pconverge_702735 = _681239;
goto l702734;
l702733: ;
pconverge_702735 = _701347;
goto l702734;
l702734: ;
converge_702735 = pconverge_702735;
pconverge_681880 = converge_702735;
goto l681879;
l681878: ;
pconverge_681880 = 0;
goto l681879;
l681879: ;
converge_681880 = pconverge_681880;
if (_681244) goto l681881; else goto l702727;
l702727: ;
if (_701516) goto l702728; else goto l702731;
l702731: ;
pconverge_702730 = xi_681232;
goto l702729;
l702728: ;
pconverge_702730 = _701347;
goto l702729;
l702729: ;
converge_702730 = pconverge_702730;
pconverge_681883 = converge_702730;
goto l681882;
l681881: ;
pconverge_681883 = 0;
goto l681882;
l681882: ;
converge_681883 = pconverge_681883;
if (_681249) goto l681884; else goto l702722;
l702722: ;
if (_701356) goto l702723; else goto l702726;
l702726: ;
pconverge_702725 = _681248;
goto l702724;
l702723: ;
pconverge_702725 = _701347;
goto l702724;
l702724: ;
converge_702725 = pconverge_702725;
pconverge_681886 = converge_702725;
goto l681885;
l681884: ;
pconverge_681886 = 0;
goto l681885;
l681885: ;
converge_681886 = pconverge_681886;
if (_681254) goto l681887; else goto l702717;
l702717: ;
if (_701350) goto l702718; else goto l702721;
l702721: ;
pconverge_702720 = _681253;
goto l702719;
l702718: ;
pconverge_702720 = _701347;
goto l702719;
l702719: ;
converge_702720 = pconverge_702720;
pconverge_681889 = converge_702720;
goto l681888;
l681887: ;
pconverge_681889 = 0;
goto l681888;
l681888: ;
converge_681889 = pconverge_681889;
if (_681435) goto l681890; else goto l702712;
l702712: ;
if (_701500) goto l702713; else goto l702716;
l702716: ;
pconverge_702715 = _681434;
goto l702714;
l702713: ;
pconverge_702715 = _701379;
goto l702714;
l702714: ;
converge_702715 = pconverge_702715;
pconverge_681892 = converge_702715;
goto l681891;
l681890: ;
pconverge_681892 = 0;
goto l681891;
l681891: ;
converge_681892 = pconverge_681892;
if (_681341) goto l681893; else goto l702707;
l702707: ;
if (_701368) goto l702708; else goto l702711;
l702711: ;
pconverge_702710 = _681340;
goto l702709;
l702708: ;
pconverge_702710 = _701347;
goto l702709;
l702709: ;
converge_702710 = pconverge_702710;
pconverge_681895 = converge_702710;
goto l681894;
l681893: ;
pconverge_681895 = 0;
goto l681894;
l681894: ;
converge_681895 = pconverge_681895;
if (_681346) goto l681896; else goto l702702;
l702702: ;
if (_701362) goto l702703; else goto l702706;
l702706: ;
pconverge_702705 = _681345;
goto l702704;
l702703: ;
pconverge_702705 = _701347;
goto l702704;
l702704: ;
converge_702705 = pconverge_702705;
pconverge_681898 = converge_702705;
goto l681897;
l681896: ;
pconverge_681898 = 0;
goto l681897;
l681897: ;
converge_681898 = pconverge_681898;
if (_681249) goto l681899; else goto l702697;
l702697: ;
if (_701356) goto l702698; else goto l702701;
l702701: ;
pconverge_702700 = _681248;
goto l702699;
l702698: ;
pconverge_702700 = _701347;
goto l702699;
l702699: ;
converge_702700 = pconverge_702700;
pconverge_681901 = converge_702700;
goto l681900;
l681899: ;
pconverge_681901 = 0;
goto l681900;
l681900: ;
converge_681901 = pconverge_681901;
if (_681254) goto l681902; else goto l702692;
l702692: ;
if (_701350) goto l702693; else goto l702696;
l702696: ;
pconverge_702695 = _681253;
goto l702694;
l702693: ;
pconverge_702695 = _701347;
goto l702694;
l702694: ;
converge_702695 = pconverge_702695;
pconverge_681904 = converge_702695;
goto l681903;
l681902: ;
pconverge_681904 = 0;
goto l681903;
l681903: ;
converge_681904 = pconverge_681904;
if (_681358) goto l681905; else goto l702687;
l702687: ;
if (_701343) goto l702688; else goto l702691;
l702691: ;
pconverge_702690 = _681357;
goto l702689;
l702688: ;
pconverge_702690 = _701347;
goto l702689;
l702689: ;
converge_702690 = pconverge_702690;
pconverge_681907 = converge_702690;
goto l681906;
l681905: ;
pconverge_681907 = 0;
goto l681906;
l681906: ;
converge_681907 = pconverge_681907;
if (_681455) goto l681908; else goto l702682;
l702682: ;
if (_701469) goto l702683; else goto l702686;
l702686: ;
pconverge_702685 = _681454;
goto l702684;
l702683: ;
pconverge_702685 = _701379;
goto l702684;
l702684: ;
converge_702685 = pconverge_702685;
pconverge_681910 = converge_702685;
goto l681909;
l681908: ;
pconverge_681910 = 0;
goto l681909;
l681909: ;
converge_681910 = pconverge_681910;
if (_681341) goto l681911; else goto l702677;
l702677: ;
if (_701368) goto l702678; else goto l702681;
l702681: ;
pconverge_702680 = _681340;
goto l702679;
l702678: ;
pconverge_702680 = _701347;
goto l702679;
l702679: ;
converge_702680 = pconverge_702680;
pconverge_681913 = converge_702680;
goto l681912;
l681911: ;
pconverge_681913 = 0;
goto l681912;
l681912: ;
converge_681913 = pconverge_681913;
if (_681346) goto l681914; else goto l702672;
l702672: ;
if (_701362) goto l702673; else goto l702676;
l702676: ;
pconverge_702675 = _681345;
goto l702674;
l702673: ;
pconverge_702675 = _701347;
goto l702674;
l702674: ;
converge_702675 = pconverge_702675;
pconverge_681916 = converge_702675;
goto l681915;
l681914: ;
pconverge_681916 = 0;
goto l681915;
l681915: ;
converge_681916 = pconverge_681916;
if (_681249) goto l681917; else goto l702667;
l702667: ;
if (_701356) goto l702668; else goto l702671;
l702671: ;
pconverge_702670 = _681248;
goto l702669;
l702668: ;
pconverge_702670 = _701347;
goto l702669;
l702669: ;
converge_702670 = pconverge_702670;
pconverge_681919 = converge_702670;
goto l681918;
l681917: ;
pconverge_681919 = 0;
goto l681918;
l681918: ;
converge_681919 = pconverge_681919;
if (_681254) goto l681920; else goto l702662;
l702662: ;
if (_701350) goto l702663; else goto l702666;
l702666: ;
pconverge_702665 = _681253;
goto l702664;
l702663: ;
pconverge_702665 = _701347;
goto l702664;
l702664: ;
converge_702665 = pconverge_702665;
pconverge_681922 = converge_702665;
goto l681921;
l681920: ;
pconverge_681922 = 0;
goto l681921;
l681921: ;
converge_681922 = pconverge_681922;
if (_681358) goto l681923; else goto l702657;
l702657: ;
if (_701343) goto l702658; else goto l702661;
l702661: ;
pconverge_702660 = _681357;
goto l702659;
l702658: ;
pconverge_702660 = _701347;
goto l702659;
l702659: ;
converge_702660 = pconverge_702660;
pconverge_681925 = converge_702660;
goto l681924;
l681923: ;
pconverge_681925 = 0;
goto l681924;
l681924: ;
converge_681925 = pconverge_681925;
if (_681298) goto l681926; else goto l702652;
l702652: ;
if (_701438) goto l702653; else goto l702656;
l702656: ;
pconverge_702655 = _681297;
goto l702654;
l702653: ;
pconverge_702655 = _701379;
goto l702654;
l702654: ;
converge_702655 = pconverge_702655;
pconverge_681928 = converge_702655;
goto l681927;
l681926: ;
pconverge_681928 = 0;
goto l681927;
l681927: ;
converge_681928 = pconverge_681928;
if (_681341) goto l681929; else goto l702647;
l702647: ;
if (_701368) goto l702648; else goto l702651;
l702651: ;
pconverge_702650 = _681340;
goto l702649;
l702648: ;
pconverge_702650 = _701347;
goto l702649;
l702649: ;
converge_702650 = pconverge_702650;
pconverge_681931 = converge_702650;
goto l681930;
l681929: ;
pconverge_681931 = 0;
goto l681930;
l681930: ;
converge_681931 = pconverge_681931;
if (_681346) goto l681932; else goto l702642;
l702642: ;
if (_701362) goto l702643; else goto l702646;
l702646: ;
pconverge_702645 = _681345;
goto l702644;
l702643: ;
pconverge_702645 = _701347;
goto l702644;
l702644: ;
converge_702645 = pconverge_702645;
pconverge_681934 = converge_702645;
goto l681933;
l681932: ;
pconverge_681934 = 0;
goto l681933;
l681933: ;
converge_681934 = pconverge_681934;
if (_681249) goto l681935; else goto l702637;
l702637: ;
if (_701356) goto l702638; else goto l702641;
l702641: ;
pconverge_702640 = _681248;
goto l702639;
l702638: ;
pconverge_702640 = _701347;
goto l702639;
l702639: ;
converge_702640 = pconverge_702640;
pconverge_681937 = converge_702640;
goto l681936;
l681935: ;
pconverge_681937 = 0;
goto l681936;
l681936: ;
converge_681937 = pconverge_681937;
if (_681254) goto l681938; else goto l702632;
l702632: ;
if (_701350) goto l702633; else goto l702636;
l702636: ;
pconverge_702635 = _681253;
goto l702634;
l702633: ;
pconverge_702635 = _701347;
goto l702634;
l702634: ;
converge_702635 = pconverge_702635;
pconverge_681940 = converge_702635;
goto l681939;
l681938: ;
pconverge_681940 = 0;
goto l681939;
l681939: ;
converge_681940 = pconverge_681940;
if (_681358) goto l681941; else goto l702627;
l702627: ;
if (_701343) goto l702628; else goto l702631;
l702631: ;
pconverge_702630 = _681357;
goto l702629;
l702628: ;
pconverge_702630 = _701347;
goto l702629;
l702629: ;
converge_702630 = pconverge_702630;
pconverge_681943 = converge_702630;
goto l681942;
l681941: ;
pconverge_681943 = 0;
goto l681942;
l681942: ;
converge_681943 = pconverge_681943;
if (_681318) goto l681944; else goto l702622;
l702622: ;
if (_701407) goto l702623; else goto l702626;
l702626: ;
pconverge_702625 = _681317;
goto l702624;
l702623: ;
pconverge_702625 = _701379;
goto l702624;
l702624: ;
converge_702625 = pconverge_702625;
pconverge_681946 = converge_702625;
goto l681945;
l681944: ;
pconverge_681946 = 0;
goto l681945;
l681945: ;
converge_681946 = pconverge_681946;
if (_681341) goto l681947; else goto l702617;
l702617: ;
if (_701368) goto l702618; else goto l702621;
l702621: ;
pconverge_702620 = _681340;
goto l702619;
l702618: ;
pconverge_702620 = _701347;
goto l702619;
l702619: ;
converge_702620 = pconverge_702620;
pconverge_681949 = converge_702620;
goto l681948;
l681947: ;
pconverge_681949 = 0;
goto l681948;
l681948: ;
converge_681949 = pconverge_681949;
if (_681346) goto l681950; else goto l702612;
l702612: ;
if (_701362) goto l702613; else goto l702616;
l702616: ;
pconverge_702615 = _681345;
goto l702614;
l702613: ;
pconverge_702615 = _701347;
goto l702614;
l702614: ;
converge_702615 = pconverge_702615;
pconverge_681952 = converge_702615;
goto l681951;
l681950: ;
pconverge_681952 = 0;
goto l681951;
l681951: ;
converge_681952 = pconverge_681952;
if (_681249) goto l681953; else goto l702607;
l702607: ;
if (_701356) goto l702608; else goto l702611;
l702611: ;
pconverge_702610 = _681248;
goto l702609;
l702608: ;
pconverge_702610 = _701347;
goto l702609;
l702609: ;
converge_702610 = pconverge_702610;
pconverge_681955 = converge_702610;
goto l681954;
l681953: ;
pconverge_681955 = 0;
goto l681954;
l681954: ;
converge_681955 = pconverge_681955;
if (_681254) goto l681956; else goto l702602;
l702602: ;
if (_701350) goto l702603; else goto l702606;
l702606: ;
pconverge_702605 = _681253;
goto l702604;
l702603: ;
pconverge_702605 = _701347;
goto l702604;
l702604: ;
converge_702605 = pconverge_702605;
pconverge_681958 = converge_702605;
goto l681957;
l681956: ;
pconverge_681958 = 0;
goto l681957;
l681957: ;
converge_681958 = pconverge_681958;
if (_681358) goto l681959; else goto l702597;
l702597: ;
if (_701343) goto l702598; else goto l702601;
l702601: ;
pconverge_702600 = _681357;
goto l702599;
l702598: ;
pconverge_702600 = _701347;
goto l702599;
l702599: ;
converge_702600 = pconverge_702600;
pconverge_681961 = converge_702600;
goto l681960;
l681959: ;
pconverge_681961 = 0;
goto l681960;
l681960: ;
converge_681961 = pconverge_681961;
if (_681511) goto l681962; else goto l702592;
l702592: ;
if (_701375) goto l702593; else goto l702596;
l702596: ;
pconverge_702595 = _681510;
goto l702594;
l702593: ;
pconverge_702595 = _701379;
goto l702594;
l702594: ;
converge_702595 = pconverge_702595;
pconverge_681964 = converge_702595;
goto l681963;
l681962: ;
pconverge_681964 = 0;
goto l681963;
l681963: ;
converge_681964 = pconverge_681964;
if (_681341) goto l681965; else goto l702587;
l702587: ;
if (_701368) goto l702588; else goto l702591;
l702591: ;
pconverge_702590 = _681340;
goto l702589;
l702588: ;
pconverge_702590 = _701347;
goto l702589;
l702589: ;
converge_702590 = pconverge_702590;
pconverge_681967 = converge_702590;
goto l681966;
l681965: ;
pconverge_681967 = 0;
goto l681966;
l681966: ;
converge_681967 = pconverge_681967;
if (_681346) goto l681968; else goto l702582;
l702582: ;
if (_701362) goto l702583; else goto l702586;
l702586: ;
pconverge_702585 = _681345;
goto l702584;
l702583: ;
pconverge_702585 = _701347;
goto l702584;
l702584: ;
converge_702585 = pconverge_702585;
pconverge_681970 = converge_702585;
goto l681969;
l681968: ;
pconverge_681970 = 0;
goto l681969;
l681969: ;
converge_681970 = pconverge_681970;
if (_681249) goto l681971; else goto l702577;
l702577: ;
if (_701356) goto l702578; else goto l702581;
l702581: ;
pconverge_702580 = _681248;
goto l702579;
l702578: ;
pconverge_702580 = _701347;
goto l702579;
l702579: ;
converge_702580 = pconverge_702580;
pconverge_681973 = converge_702580;
goto l681972;
l681971: ;
pconverge_681973 = 0;
goto l681972;
l681972: ;
converge_681973 = pconverge_681973;
if (_681254) goto l681974; else goto l702572;
l702572: ;
if (_701350) goto l702573; else goto l702576;
l702576: ;
pconverge_702575 = _681253;
goto l702574;
l702573: ;
pconverge_702575 = _701347;
goto l702574;
l702574: ;
converge_702575 = pconverge_702575;
pconverge_681976 = converge_702575;
goto l681975;
l681974: ;
pconverge_681976 = 0;
goto l681975;
l681975: ;
converge_681976 = pconverge_681976;
if (_681358) goto l681977; else goto l702567;
l702567: ;
if (_701343) goto l702568; else goto l702571;
l702571: ;
pconverge_702570 = _681357;
goto l702569;
l702568: ;
pconverge_702570 = _701347;
goto l702569;
l702569: ;
converge_702570 = pconverge_702570;
pconverge_681979 = converge_702570;
goto l681978;
l681977: ;
pconverge_681979 = 0;
goto l681978;
l681978: ;
converge_681979 = pconverge_681979;
int _686977;
_686977 = converge_681856 * gwidth_681983;
int _683500;
_683500 = converge_681438 * gwidth_681983;
int _683651;
_683651 = converge_681458 * gwidth_681983;
int _684708;
_684708 = converge_681586 * gwidth_681983;
int _683712;
_683712 = _683651 + converge_681467;
int _687068;
_687068 = _686977 + converge_681868;
int _687038;
_687038 = _686977 + converge_681865;
int _684739;
_684739 = _684708 + converge_681592;
int _683713;
_683713 = 14 * _683712;
int _682443;
_682443 = converge_681301 * gwidth_681983;
int _683198;
_683198 = converge_681400 * gwidth_681983;
int _687039;
_687039 = 14 * _687038;
int _686826;
_686826 = converge_681838 * gwidth_681983;
int _686373;
_686373 = converge_681784 * gwidth_681983;
int _682564;
_682564 = _682443 + converge_681316;
int _683802;
_683802 = converge_681476 * gwidth_681983;
int _686827;
_686827 = _686826 + converge_681841;
int _687128;
_687128 = converge_681874 * gwidth_681983;
int _684557;
_684557 = converge_681568 * gwidth_681983;
int _684588;
_684588 = _684557 + converge_681574;
int _683893;
_683893 = _683802 + converge_681488;
float zv_681988;
zv_681988 = 1.000000e+01f * converge_681222;
int _684829;
_684829 = _684708 + converge_681601;
int _684859;
_684859 = converge_681604 * gwidth_681983;
int _682534;
_682534 = _682443 + converge_681313;
int _686978;
_686978 = _686977 + converge_681859;
int _684860;
_684860 = _684859 + converge_681607;
int _687430;
_687430 = converge_681910 * gwidth_681983;
int _684589;
_684589 = 14 * _684588;
int _685618;
_685618 = converge_681694 * gwidth_681983;
int _686675;
_686675 = converge_681820 * gwidth_681983;
int _683259;
_683259 = _683198 + converge_681409;
int _684678;
_684678 = _684557 + converge_681583;
int _687129;
_687129 = _687128 + converge_681877;
int _686524;
_686524 = converge_681802 * gwidth_681983;
int _686828;
_686828 = 14 * _686827;
int zi_681989;
zi_681989 = (int)zv_681988;
int _683289;
_683289 = _683198 + converge_681412;
int _687008;
_687008 = _686977 + converge_681862;
int _683561;
_683561 = _683500 + converge_681447;
int _682565;
_682565 = 14 * _682564;
int _683260;
_683260 = 14 * _683259;
int _685467;
_685467 = converge_681676 * gwidth_681983;
int _687431;
_687431 = _687430 + converge_681913;
int _685528;
_685528 = _685467 + converge_681685;
int _685619;
_685619 = _685618 + converge_681697;
int _684861;
_684861 = 14 * _684860;
int _687052;
_687052 = _687039 + zi_681989;
int _683953;
_683953 = converge_681494 * gwidth_681983;
int _685468;
_685468 = _685467 + converge_681679;
int _685165;
_685165 = converge_681640 * gwidth_681983;
int _684255;
_684255 = converge_681532 * gwidth_681983;
int _685739;
_685739 = _685618 + converge_681709;
int _683863;
_683863 = _683802 + converge_681485;
int _682745;
_682745 = converge_681339 * gwidth_681983;
int _685196;
_685196 = _685165 + converge_681646;
int _686841;
_686841 = _686828 + zi_681989;
int _687069;
_687069 = 14 * _687068;
int _684286;
_684286 = _684255 + converge_681538;
int _684618;
_684618 = _684557 + converge_681577;
int _687279;
_687279 = converge_681892 * gwidth_681983;
int _684740;
_684740 = 14 * _684739;
int _682836;
_682836 = _682745 + converge_681355;
int _686796;
_686796 = _686675 + converge_681835;
int _683319;
_683319 = _683198 + converge_681415;
int _686525;
_686525 = _686524 + converge_681805;
int _686736;
_686736 = _686675 + converge_681829;
int _686434;
_686434 = _686373 + converge_681793;
int _684920;
_684920 = _684859 + converge_681613;
int _681997;
_681997 = zi_681989 - 1;
int _682292;
_682292 = converge_681281 * gwidth_681983;
int _684346;
_684346 = _684255 + converge_681544;
int _682776;
_682776 = _682745 + converge_681349;
int _683290;
_683290 = 14 * _683289;
int _687521;
_687521 = _687430 + converge_681922;
int _686494;
_686494 = _686373 + converge_681799;
int _685316;
_685316 = converge_681658 * gwidth_681983;
int _684830;
_684830 = 14 * _684829;
int _682141;
_682141 = converge_681262 * gwidth_681983;
int _682896;
_682896 = converge_681364 * gwidth_681983;
int _687130;
_687130 = 14 * _687129;
int _684874;
_684874 = _684861 + zi_681989;
int _682353;
_682353 = _682292 + converge_681290;
int _683923;
_683923 = _683802 + converge_681491;
int _683924;
_683924 = 14 * _683923;
int _686526;
_686526 = 14 * _686525;
int _684679;
_684679 = 14 * _684678;
int _684709;
_684709 = _684708 + converge_681589;
int _682474;
_682474 = _682443 + converge_681307;
int _686222;
_686222 = converge_681766 * gwidth_681983;
int _682354;
_682354 = 14 * _682353;
int _683894;
_683894 = 14 * _683893;
int _683501;
_683501 = _683500 + converge_681441;
int _682594;
_682594 = converge_681321 * gwidth_681983;
int _685256;
_685256 = _685165 + converge_681652;
int _687732;
_687732 = converge_681946 * gwidth_681983;
int _687491;
_687491 = _687430 + converge_681919;
int _683720;
_683720 = _683713 + _681997;
int _686615;
_686615 = _686524 + converge_681814;
int _684753;
_684753 = _684740 + zi_681989;
int _682777;
_682777 = 14 * _682776;
int _684950;
_684950 = _684859 + converge_681616;
int _681984;
_681984 = converge_681231 * gwidth_681983;
int _682784;
_682784 = _682777 + _681997;
int _685920;
_685920 = converge_681730 * gwidth_681983;
int _686374;
_686374 = _686373 + converge_681787;
int _684256;
_684256 = _684255 + converge_681535;
int _682837;
_682837 = 14 * _682836;
int _687883;
_687883 = converge_681964 * gwidth_681983;
int _684257;
_684257 = 14 * _684256;
int _685620;
_685620 = 14 * _685619;
int _686404;
_686404 = _686373 + converge_681790;
int _683833;
_683833 = _683802 + converge_681482;
int _683229;
_683229 = _683198 + converge_681406;
int _684406;
_684406 = converge_681550 * gwidth_681983;
int _683047;
_683047 = converge_681382 * gwidth_681983;
int _683531;
_683531 = _683500 + converge_681444;
int _685588;
_685588 = _685467 + converge_681691;
int _683267;
_683267 = _683260 + _681997;
int _685558;
_685558 = _685467 + converge_681688;
int _685740;
_685740 = 14 * _685739;
int _685981;
_685981 = _685920 + converge_681739;
int _683108;
_683108 = _683047 + converge_681391;
int _684648;
_684648 = _684557 + converge_681580;
int _687733;
_687733 = _687732 + converge_681949;
int _683682;
_683682 = _683651 + converge_681464;
int _682111;
_682111 = _681984 + converge_681257;
int _684754;
_684754 = 2 + _684753;
int _682051;
_682051 = _681984 + converge_681247;
int _682655;
_682655 = _682594 + converge_681330;
int _684755;
_684755 = 2 * _684754;
int _683652;
_683652 = _683651 + converge_681461;
int _687310;
_687310 = _687279 + converge_681898;
int _682850;
_682850 = _682837 + zi_681989;
int _686283;
_686283 = _686222 + converge_681775;
int _682413;
_682413 = _682292 + converge_681296;
int _684686;
_684686 = _684679 + _681997;
int _682806;
_682806 = _682745 + converge_681352;
int _687581;
_687581 = converge_681928 * gwidth_681983;
int _685498;
_685498 = _685467 + converge_681682;
int _687340;
_687340 = _687279 + converge_681901;
int _682323;
_682323 = _682292 + converge_681287;
int _683199;
_683199 = _683198 + converge_681403;
int _684437;
_684437 = _684406 + converge_681556;
int _683937;
_683937 = _683924 + zi_681989;
int _687098;
_687098 = _686977 + converge_681871;
int _683273;
_683273 = _683260 + zi_681989;
int _684875;
_684875 = 2 + _684874;
int _686857;
_686857 = _686826 + converge_681844;
int _682572;
_682572 = _682565 + _681997;
int _687159;
_687159 = _687128 + converge_681880;
int _683138;
_683138 = _683047 + converge_681394;
int _685769;
_685769 = converge_681712 * gwidth_681983;
int _684799;
_684799 = _684708 + converge_681598;
int _683621;
_683621 = _683500 + converge_681453;
int _685529;
_685529 = 14 * _685528;
int _687053;
_687053 = 3 + _687052;
int _682504;
_682504 = _682443 + converge_681310;
int _687461;
_687461 = _687430 + converge_681916;
int _685649;
_685649 = _685618 + converge_681700;
int _685010;
_685010 = converge_681622 * gwidth_681983;
int _687063;
_687063 = 5 + _687052;
int _684497;
_684497 = _684406 + converge_681562;
int _683349;
_683349 = converge_681418 * gwidth_681983;
int _685951;
_685951 = _685920 + converge_681736;
int _685830;
_685830 = _685769 + converge_681721;
int _682851;
_682851 = 2 + _682850;
int _683591;
_683591 = _683500 + converge_681450;
int _683772;
_683772 = _683651 + converge_681473;
int _686071;
_686071 = converge_681748 * gwidth_681983;
int _683410;
_683410 = _683349 + converge_681427;
int _688004;
_688004 = _687883 + converge_681979;
int _687763;
_687763 = _687732 + converge_681952;
int _682573;
_682573 = 2 + _682572;
int _686706;
_686706 = _686675 + converge_681826;
int _684104;
_684104 = converge_681514 * gwidth_681983;
int _683864;
_683864 = 14 * _683863;
int _684868;
_684868 = _684861 + _681997;
int _682324;
_682324 = 14 * _682323;
int _683742;
_683742 = _683651 + converge_681470;
int _684769;
_684769 = _684708 + converge_681595;
int _683726;
_683726 = _683713 + zi_681989;
int _682444;
_682444 = _682443 + converge_681304;
int _686887;
_686887 = _686826 + converge_681847;
int _686947;
_686947 = _686826 + converge_681853;
int _686917;
_686917 = _686826 + converge_681850;
int _686464;
_686464 = _686373 + converge_681796;
int _683803;
_683803 = _683802 + converge_681479;
int _687219;
_687219 = _687128 + converge_681886;
int _687249;
_687249 = _687128 + converge_681889;
int _687189;
_687189 = _687128 + converge_681883;
int _684558;
_684558 = _684557 + converge_681571;
int _684980;
_684980 = _684859 + converge_681619;
int _684890;
_684890 = _684859 + converge_681610;
int _682535;
_682535 = 14 * _682534;
int _686979;
_686979 = 14 * _686978;
int _687551;
_687551 = _687430 + converge_681925;
int _684602;
_684602 = _684589 + zi_681989;
int _684596;
_684596 = _684589 + _681997;
int _685679;
_685679 = _685618 + converge_681703;
int _685709;
_685709 = _685618 + converge_681706;
int _686766;
_686766 = _686675 + converge_681832;
int _686676;
_686676 = _686675 + converge_681823;
int _686645;
_686645 = _686524 + converge_681817;
int _686585;
_686585 = _686524 + converge_681811;
int _686555;
_686555 = _686524 + converge_681808;
int _685013;
_685013 = 1 + zi_681989;
int _685633;
_685633 = _685620 + zi_681989;
int _682790;
_682790 = _682777 + zi_681989;
int _682367;
_682367 = _682354 + zi_681989;
int _684692;
_684692 = _684679 + zi_681989;
int _684270;
_684270 = _684257 + zi_681989;
int _685542;
_685542 = _685529 + zi_681989;
int _684843;
_684843 = _684830 + zi_681989;
int _681990;
_681990 = zi_681989 - 2;
int _686992;
_686992 = _686979 + zi_681989;
int _683877;
_683877 = _683864 + zi_681989;
int _687082;
_687082 = _687069 + zi_681989;
int _683303;
_683303 = _683290 + zi_681989;
int _683907;
_683907 = _683894 + zi_681989;
int _682578;
_682578 = _682565 + zi_681989;
int _686539;
_686539 = _686526 + zi_681989;
int _687143;
_687143 = _687130 + zi_681989;
int _685753;
_685753 = _685740 + zi_681989;
int _682337;
_682337 = _682324 + zi_681989;
int _682548;
_682548 = _682535 + zi_681989;
int _687009;
_687009 = 14 * _687008;
int _683562;
_683562 = 14 * _683561;
int _682566;
_682566 = _682565 + _681990;
int _683261;
_683261 = _683260 + _681990;
int _687432;
_687432 = 14 * _687431;
int _684862;
_684862 = _684861 + _681990;
int _687058;
_687058 = 4 + _687052;
int _683954;
_683954 = _683953 + converge_681497;
int _683984;
_683984 = _683953 + converge_681500;
int _684014;
_684014 = _683953 + converge_681503;
int _684074;
_684074 = _683953 + converge_681509;
int _684044;
_684044 = _683953 + converge_681506;
int _685469;
_685469 = 14 * _685468;
int _685286;
_685286 = _685165 + converge_681655;
int _685226;
_685226 = _685165 + converge_681649;
int _685166;
_685166 = _685165 + converge_681643;
int _684316;
_684316 = _684255 + converge_681541;
int _684376;
_684376 = _684255 + converge_681547;
int _682746;
_682746 = _682745 + converge_681344;
int _682866;
_682866 = _682745 + converge_681361;
int _685197;
_685197 = 14 * _685196;
int _686852;
_686852 = 5 + _686841;
int _686847;
_686847 = 4 + _686841;
int _686842;
_686842 = 3 + _686841;
int _684287;
_684287 = 14 * _684286;
int _684619;
_684619 = 14 * _684618;
int _687280;
_687280 = _687279 + converge_681895;
int _687370;
_687370 = _687279 + converge_681904;
int _687400;
_687400 = _687279 + converge_681907;
int _684741;
_684741 = _684740 + _681990;
int _684747;
_684747 = _684740 + _681997;
int _686797;
_686797 = 14 * _686796;
int _683320;
_683320 = 14 * _683319;
int _686737;
_686737 = 14 * _686736;
int _686435;
_686435 = 14 * _686434;
int _684921;
_684921 = 14 * _684920;
int _682542;
_682542 = _682535 + _681997;
int _683327;
_683327 = _683320 + _681997;
int _684626;
_684626 = _684619 + _681997;
int _683569;
_683569 = _683562 + _681997;
int _683931;
_683931 = _683924 + _681997;
int _684928;
_684928 = _684921 + _681997;
int _683871;
_683871 = _683864 + _681997;
int _682844;
_682844 = _682837 + _681997;
int _684294;
_684294 = _684287 + _681997;
int _682361;
_682361 = _682354 + _681997;
int _683297;
_683297 = _683290 + _681997;
int _682331;
_682331 = _682324 + _681997;
int _684837;
_684837 = _684830 + _681997;
int _684264;
_684264 = _684257 + _681997;
int _683901;
_683901 = _683894 + _681997;
int _682383;
_682383 = _682292 + converge_681293;
int _682293;
_682293 = _682292 + converge_681284;
int _684347;
_684347 = 14 * _684346;
int _683291;
_683291 = _683290 + _681990;
int _687522;
_687522 = 14 * _687521;
int _686495;
_686495 = 14 * _686494;
int _685317;
_685317 = _685316 + converge_681661;
int _685377;
_685377 = _685316 + converge_681667;
int _685407;
_685407 = _685316 + converge_681670;
int _685347;
_685347 = _685316 + converge_681664;
int _685437;
_685437 = _685316 + converge_681673;
int _684831;
_684831 = _684830 + _681990;
int _682202;
_682202 = _682141 + converge_681271;
int _682262;
_682262 = _682141 + converge_681277;
int _682232;
_682232 = _682141 + converge_681274;
int _682172;
_682172 = _682141 + converge_681268;
int _682142;
_682142 = _682141 + converge_681265;
int _682987;
_682987 = _682896 + converge_681376;
int _682927;
_682927 = _682896 + converge_681370;
int _682897;
_682897 = _682896 + converge_681367;
int _682957;
_682957 = _682896 + converge_681373;
int _683017;
_683017 = _682896 + converge_681379;
int _684885;
_684885 = 4 + _684874;
int _684880;
_684880 = 3 + _684874;
int _683925;
_683925 = _683924 + _681990;
int _684680;
_684680 = _684679 + _681990;
int _684710;
_684710 = 14 * _684709;
int _682475;
_682475 = 14 * _682474;
int _686313;
_686313 = _686222 + converge_681778;
int _686223;
_686223 = _686222 + converge_681769;
int _686343;
_686343 = _686222 + converge_681781;
int _686253;
_686253 = _686222 + converge_681772;
int _682355;
_682355 = _682354 + _681990;
int _683895;
_683895 = _683894 + _681990;
int _683502;
_683502 = 14 * _683501;
int _682715;
_682715 = _682594 + converge_681336;
int _682595;
_682595 = _682594 + converge_681324;
int _682685;
_682685 = _682594 + converge_681333;
int _682625;
_682625 = _682594 + converge_681327;
int _685257;
_685257 = 14 * _685256;
int _687823;
_687823 = _687732 + converge_681958;
int _687853;
_687853 = _687732 + converge_681961;
int _687793;
_687793 = _687732 + converge_681955;
int _687492;
_687492 = 14 * _687491;
int _683721;
_683721 = 2 + _683720;
int _686616;
_686616 = 14 * _686615;
int _684764;
_684764 = 4 + _684753;
int _684759;
_684759 = 3 + _684753;
int _682778;
_682778 = _682777 + _681990;
int _684951;
_684951 = 14 * _684950;
int _682081;
_682081 = _681984 + converge_681252;
int _682021;
_682021 = _681984 + converge_681243;
int _681985;
_681985 = _681984 + converge_681237;
int _682785;
_682785 = 2 + _682784;
int _686011;
_686011 = _685920 + converge_681742;
int _685921;
_685921 = _685920 + converge_681733;
int _686041;
_686041 = _685920 + converge_681745;
int _686375;
_686375 = 14 * _686374;
int _682838;
_682838 = _682837 + _681990;
int _687944;
_687944 = _687883 + converge_681973;
int _687974;
_687974 = _687883 + converge_681976;
int _687914;
_687914 = _687883 + converge_681970;
int _687884;
_687884 = _687883 + converge_681967;
int _684258;
_684258 = _684257 + _681990;
int _686405;
_686405 = 14 * _686404;
int _683834;
_683834 = 14 * _683833;
int _683230;
_683230 = 14 * _683229;
int _684407;
_684407 = _684406 + converge_681553;
int _684467;
_684467 = _684406 + converge_681559;
int _684527;
_684527 = _684406 + converge_681565;
int _683078;
_683078 = _683047 + converge_681388;
int _683048;
_683048 = _683047 + converge_681385;
int _683168;
_683168 = _683047 + converge_681397;
int _683532;
_683532 = 14 * _683531;
int _685589;
_685589 = 14 * _685588;
int _683268;
_683268 = 2 + _683267;
int _685559;
_685559 = 14 * _685558;
int _685982;
_685982 = 14 * _685981;
int _683109;
_683109 = 14 * _683108;
int _684649;
_684649 = 14 * _684648;
int _687734;
_687734 = 14 * _687733;
int _683683;
_683683 = 14 * _683682;
int _682112;
_682112 = 14 * _682111;
int _682052;
_682052 = 14 * _682051;
int _682656;
_682656 = 14 * _682655;
float* _684756;
_684756 = _453093_681168 + _684755;
int _683653;
_683653 = 14 * _683652;
int _687311;
_687311 = 14 * _687310;
int _682861;
_682861 = 4 + _682850;
int _682856;
_682856 = 3 + _682850;
int _686284;
_686284 = 14 * _686283;
int _682414;
_682414 = 14 * _682413;
int _684687;
_684687 = 2 + _684686;
int _682807;
_682807 = 14 * _682806;
int _687642;
_687642 = _687581 + converge_681937;
int _687612;
_687612 = _687581 + converge_681934;
int _687672;
_687672 = _687581 + converge_681940;
int _687582;
_687582 = _687581 + converge_681931;
int _687702;
_687702 = _687581 + converge_681943;
int _685499;
_685499 = 14 * _685498;
int _687341;
_687341 = 14 * _687340;
int _683200;
_683200 = 14 * _683199;
int _684438;
_684438 = 14 * _684437;
int _683948;
_683948 = 4 + _683937;
int _683943;
_683943 = 3 + _683937;
int _683938;
_683938 = 2 + _683937;
int _687099;
_687099 = 14 * _687098;
int _683284;
_683284 = 4 + _683273;
int _683279;
_683279 = 3 + _683273;
int _683274;
_683274 = 2 + _683273;
int _684876;
_684876 = 2 * _684875;
int _686858;
_686858 = 14 * _686857;
int _687160;
_687160 = 14 * _687159;
int _683139;
_683139 = 14 * _683138;
int _685890;
_685890 = _685769 + converge_681727;
int _685770;
_685770 = _685769 + converge_681715;
int _685860;
_685860 = _685769 + converge_681724;
int _685800;
_685800 = _685769 + converge_681718;
int _684800;
_684800 = 14 * _684799;
int _683622;
_683622 = 14 * _683621;
int _687054;
_687054 = 2 * _687053;
int _682505;
_682505 = 14 * _682504;
int _687462;
_687462 = 14 * _687461;
int _685650;
_685650 = 14 * _685649;
int _685075;
_685075 = _685010 + converge_681631;
int _685135;
_685135 = _685010 + converge_681637;
int _685105;
_685105 = _685010 + converge_681634;
int _685011;
_685011 = _685010 + converge_681625;
int _685045;
_685045 = _685010 + converge_681628;
int _687064;
_687064 = 2 * _687063;
int _684498;
_684498 = 14 * _684497;
int _683380;
_683380 = _683349 + converge_681424;
int _683470;
_683470 = _683349 + converge_681433;
int _683440;
_683440 = _683349 + converge_681430;
int _683350;
_683350 = _683349 + converge_681421;
int _685952;
_685952 = 14 * _685951;
int _685831;
_685831 = 14 * _685830;
int _682852;
_682852 = 2 * _682851;
int _683592;
_683592 = 14 * _683591;
int _683773;
_683773 = 14 * _683772;
int _686162;
_686162 = _686071 + converge_681760;
int _686102;
_686102 = _686071 + converge_681754;
int _686072;
_686072 = _686071 + converge_681751;
int _686192;
_686192 = _686071 + converge_681763;
int _686132;
_686132 = _686071 + converge_681757;
int _683411;
_683411 = 14 * _683410;
int _688005;
_688005 = 14 * _688004;
int _687764;
_687764 = 14 * _687763;
int _682574;
_682574 = 2 * _682573;
int _686707;
_686707 = 14 * _686706;
int _684195;
_684195 = _684104 + converge_681526;
int _684225;
_684225 = _684104 + converge_681529;
int _684105;
_684105 = _684104 + converge_681517;
int _684165;
_684165 = _684104 + converge_681523;
int _684135;
_684135 = _684104 + converge_681520;
int _683865;
_683865 = _683864 + _681990;
int _684869;
_684869 = 2 + _684868;
int _682325;
_682325 = _682324 + _681990;
int _683743;
_683743 = 14 * _683742;
int _684770;
_684770 = 14 * _684769;
int _683737;
_683737 = 4 + _683726;
int _683732;
_683732 = 3 + _683726;
int _683727;
_683727 = 2 + _683726;
int _682445;
_682445 = 14 * _682444;
int _686888;
_686888 = 14 * _686887;
int _686948;
_686948 = 14 * _686947;
int _686918;
_686918 = 14 * _686917;
int _686465;
_686465 = 14 * _686464;
int _683804;
_683804 = 14 * _683803;
int _687220;
_687220 = 14 * _687219;
int _687250;
_687250 = 14 * _687249;
int _687190;
_687190 = 14 * _687189;
int _684559;
_684559 = 14 * _684558;
int _684981;
_684981 = 14 * _684980;
int _684891;
_684891 = 14 * _684890;
int _682536;
_682536 = _682535 + _681990;
int _687552;
_687552 = 14 * _687551;
int _684613;
_684613 = 4 + _684602;
int _684608;
_684608 = 3 + _684602;
int _684603;
_684603 = 2 + _684602;
int _684597;
_684597 = 2 + _684596;
int _685680;
_685680 = 14 * _685679;
int _685710;
_685710 = 14 * _685709;
int _686767;
_686767 = 14 * _686766;
int _686677;
_686677 = 14 * _686676;
int _686646;
_686646 = 14 * _686645;
int _686586;
_686586 = 14 * _686585;
int _686556;
_686556 = 14 * _686555;
int _685021;
_685021 = _685013 - 1;
int _685014;
_685014 = _685013 - 2;
int _685644;
_685644 = 5 + _685633;
int _685639;
_685639 = 4 + _685633;
int _685634;
_685634 = 3 + _685633;
int _682801;
_682801 = 4 + _682790;
int _682796;
_682796 = 3 + _682790;
int _682791;
_682791 = 2 + _682790;
int _682378;
_682378 = 4 + _682367;
int _682373;
_682373 = 3 + _682367;
int _682368;
_682368 = 2 + _682367;
int _684703;
_684703 = 4 + _684692;
int _684698;
_684698 = 3 + _684692;
int _684693;
_684693 = 2 + _684692;
int _684281;
_684281 = 4 + _684270;
int _684276;
_684276 = 3 + _684270;
int _684271;
_684271 = 2 + _684270;
int _685553;
_685553 = 5 + _685542;
int _685548;
_685548 = 4 + _685542;
int _685543;
_685543 = 3 + _685542;
int _684854;
_684854 = 4 + _684843;
int _684849;
_684849 = 3 + _684843;
int _684844;
_684844 = 2 + _684843;
int _684982;
_684982 = _684981 + _681990;
int _684650;
_684650 = _684649 + _681990;
int _684288;
_684288 = _684287 + _681990;
int _684711;
_684711 = _684710 + _681990;
int _683744;
_683744 = _683743 + _681990;
int _684922;
_684922 = _684921 + _681990;
int _682113;
_682113 = _682112 + _681990;
int _683774;
_683774 = _683773 + _681990;
int _683503;
_683503 = _683502 + _681990;
int _682053;
_682053 = _682052 + _681990;
int _682657;
_682657 = _682656 + _681990;
int _684439;
_684439 = _684438 + _681990;
int _682506;
_682506 = _682505 + _681990;
int _683623;
_683623 = _683622 + _681990;
int _684590;
_684590 = _684589 + _681990;
int _684620;
_684620 = _684619 + _681990;
int _684771;
_684771 = _684770 + _681990;
int _684560;
_684560 = _684559 + _681990;
int _683140;
_683140 = _683139 + _681990;
int _683533;
_683533 = _683532 + _681990;
int _683654;
_683654 = _683653 + _681990;
int _683321;
_683321 = _683320 + _681990;
int _683563;
_683563 = _683562 + _681990;
int _683231;
_683231 = _683230 + _681990;
int _684952;
_684952 = _684951 + _681990;
int _683110;
_683110 = _683109 + _681990;
int _683805;
_683805 = _683804 + _681990;
int _683201;
_683201 = _683200 + _681990;
int _683684;
_683684 = _683683 + _681990;
int _682808;
_682808 = _682807 + _681990;
int _682476;
_682476 = _682475 + _681990;
int _683714;
_683714 = _683713 + _681990;
int _684892;
_684892 = _684891 + _681990;
int _684348;
_684348 = _684347 + _681990;
int _683412;
_683412 = _683411 + _681990;
int _682415;
_682415 = _682414 + _681990;
int _683835;
_683835 = _683834 + _681990;
int _684801;
_684801 = _684800 + _681990;
int _682446;
_682446 = _682445 + _681990;
int _683593;
_683593 = _683592 + _681990;
int _684499;
_684499 = _684498 + _681990;
int _687003;
_687003 = 5 + _686992;
int _686998;
_686998 = 4 + _686992;
int _686993;
_686993 = 3 + _686992;
int _683888;
_683888 = 4 + _683877;
int _683883;
_683883 = 3 + _683877;
int _683878;
_683878 = 2 + _683877;
int _687093;
_687093 = 5 + _687082;
int _687088;
_687088 = 4 + _687082;
int _687083;
_687083 = 3 + _687082;
int _683314;
_683314 = 4 + _683303;
int _683309;
_683309 = 3 + _683303;
int _683304;
_683304 = 2 + _683303;
int _683918;
_683918 = 4 + _683907;
int _683913;
_683913 = 3 + _683907;
int _683908;
_683908 = 2 + _683907;
int _682589;
_682589 = 4 + _682578;
int _682584;
_682584 = 3 + _682578;
int _682579;
_682579 = 2 + _682578;
int _686550;
_686550 = 5 + _686539;
int _686545;
_686545 = 4 + _686539;
int _686540;
_686540 = 3 + _686539;
int _687154;
_687154 = 5 + _687143;
int _687149;
_687149 = 4 + _687143;
int _687144;
_687144 = 3 + _687143;
int _685764;
_685764 = 5 + _685753;
int _685759;
_685759 = 4 + _685753;
int _685754;
_685754 = 3 + _685753;
int _682348;
_682348 = 4 + _682337;
int _682343;
_682343 = 3 + _682337;
int _682338;
_682338 = 2 + _682337;
int _682559;
_682559 = 4 + _682548;
int _682554;
_682554 = 3 + _682548;
int _682549;
_682549 = 2 + _682548;
int _687022;
_687022 = _687009 + zi_681989;
int _687010;
_687010 = _687009 + _685014;
int _687016;
_687016 = _687009 + _685021;
int _683575;
_683575 = _683562 + zi_681989;
int _682567;
_682567 = 2 + _682566;
int _683262;
_683262 = 2 + _683261;
int _687445;
_687445 = _687432 + zi_681989;
int _687433;
_687433 = _687432 + _685014;
int _687439;
_687439 = _687432 + _685021;
int _684863;
_684863 = 2 + _684862;
int _687059;
_687059 = 2 * _687058;
int _683955;
_683955 = 14 * _683954;
int _683985;
_683985 = 14 * _683984;
int _684015;
_684015 = 14 * _684014;
int _684075;
_684075 = 14 * _684074;
int _684045;
_684045 = 14 * _684044;
int _685482;
_685482 = _685469 + zi_681989;
int _685470;
_685470 = _685469 + _685014;
int _685476;
_685476 = _685469 + _685021;
int _685287;
_685287 = 14 * _685286;
int _685227;
_685227 = 14 * _685226;
int _685167;
_685167 = 14 * _685166;
int _684317;
_684317 = 14 * _684316;
int _684377;
_684377 = 14 * _684376;
int _682747;
_682747 = 14 * _682746;
int _682867;
_682867 = 14 * _682866;
int _685210;
_685210 = _685197 + zi_681989;
int _685198;
_685198 = _685197 + _685014;
int _685204;
_685204 = _685197 + _685021;
int _686853;
_686853 = 2 * _686852;
int _686848;
_686848 = 2 * _686847;
int _686843;
_686843 = 2 * _686842;
int _684300;
_684300 = _684287 + zi_681989;
int _684632;
_684632 = _684619 + zi_681989;
int _687281;
_687281 = 14 * _687280;
int _687371;
_687371 = 14 * _687370;
int _687401;
_687401 = 14 * _687400;
int _684742;
_684742 = 2 + _684741;
int _684748;
_684748 = 2 + _684747;
int _686810;
_686810 = _686797 + zi_681989;
int _686798;
_686798 = _686797 + _685014;
int _686804;
_686804 = _686797 + _685021;
int _683333;
_683333 = _683320 + zi_681989;
int _686750;
_686750 = _686737 + zi_681989;
int _686738;
_686738 = _686737 + _685014;
int _686744;
_686744 = _686737 + _685021;
int _686448;
_686448 = _686435 + zi_681989;
int _686436;
_686436 = _686435 + _685014;
int _686442;
_686442 = _686435 + _685021;
int _684934;
_684934 = _684921 + zi_681989;
int _682543;
_682543 = 2 + _682542;
int _683328;
_683328 = 2 + _683327;
int _684627;
_684627 = 2 + _684626;
int _683570;
_683570 = 2 + _683569;
int _683932;
_683932 = 2 + _683931;
int _684929;
_684929 = 2 + _684928;
int _683872;
_683872 = 2 + _683871;
int _682845;
_682845 = 2 + _682844;
int _684295;
_684295 = 2 + _684294;
int _682362;
_682362 = 2 + _682361;
int _683298;
_683298 = 2 + _683297;
int _682332;
_682332 = 2 + _682331;
int _684838;
_684838 = 2 + _684837;
int _684265;
_684265 = 2 + _684264;
int _683902;
_683902 = 2 + _683901;
int _682384;
_682384 = 14 * _682383;
int _682294;
_682294 = 14 * _682293;
int _684360;
_684360 = _684347 + zi_681989;
int _684354;
_684354 = _684347 + _681997;
int _683292;
_683292 = 2 + _683291;
int _687535;
_687535 = _687522 + zi_681989;
int _687523;
_687523 = _687522 + _685014;
int _687529;
_687529 = _687522 + _685021;
int _686508;
_686508 = _686495 + zi_681989;
int _686496;
_686496 = _686495 + _685014;
int _686502;
_686502 = _686495 + _685021;
int _685318;
_685318 = 14 * _685317;
int _685378;
_685378 = 14 * _685377;
int _685408;
_685408 = 14 * _685407;
int _685348;
_685348 = 14 * _685347;
int _685438;
_685438 = 14 * _685437;
int _684832;
_684832 = 2 + _684831;
int _682203;
_682203 = 14 * _682202;
int _682263;
_682263 = 14 * _682262;
int _682233;
_682233 = 14 * _682232;
int _682173;
_682173 = 14 * _682172;
int _682143;
_682143 = 14 * _682142;
int _682988;
_682988 = 14 * _682987;
int _682928;
_682928 = 14 * _682927;
int _682898;
_682898 = 14 * _682897;
int _682958;
_682958 = 14 * _682957;
int _683018;
_683018 = 14 * _683017;
int _684886;
_684886 = 2 * _684885;
int _684881;
_684881 = 2 * _684880;
int _683926;
_683926 = 2 + _683925;
int _684681;
_684681 = 2 + _684680;
int _684723;
_684723 = _684710 + zi_681989;
int _684717;
_684717 = _684710 + _681997;
int _682488;
_682488 = _682475 + zi_681989;
int _682482;
_682482 = _682475 + _681997;
int _686314;
_686314 = 14 * _686313;
int _686224;
_686224 = 14 * _686223;
int _686344;
_686344 = 14 * _686343;
int _686254;
_686254 = 14 * _686253;
int _682356;
_682356 = 2 + _682355;
int _683896;
_683896 = 2 + _683895;
int _683515;
_683515 = _683502 + zi_681989;
int _683509;
_683509 = _683502 + _681997;
int _682716;
_682716 = 14 * _682715;
int _682596;
_682596 = 14 * _682595;
int _682686;
_682686 = 14 * _682685;
int _682626;
_682626 = 14 * _682625;
int _685270;
_685270 = _685257 + zi_681989;
int _685258;
_685258 = _685257 + _685014;
int _685264;
_685264 = _685257 + _685021;
int _687824;
_687824 = 14 * _687823;
int _687854;
_687854 = 14 * _687853;
int _687794;
_687794 = 14 * _687793;
int _687505;
_687505 = _687492 + zi_681989;
int _687493;
_687493 = _687492 + _685014;
int _687499;
_687499 = _687492 + _685021;
int _683722;
_683722 = 2 * _683721;
int _686629;
_686629 = _686616 + zi_681989;
int _686617;
_686617 = _686616 + _685014;
int _686623;
_686623 = _686616 + _685021;
int _684765;
_684765 = 2 * _684764;
int _684760;
_684760 = 2 * _684759;
int _682779;
_682779 = 2 + _682778;
int _684964;
_684964 = _684951 + zi_681989;
int _684958;
_684958 = _684951 + _681997;
int _682082;
_682082 = 14 * _682081;
int _682022;
_682022 = 14 * _682021;
int _681986;
_681986 = 14 * _681985;
int _682786;
_682786 = 2 * _682785;
int _686012;
_686012 = 14 * _686011;
int _685922;
_685922 = 14 * _685921;
int _686042;
_686042 = 14 * _686041;
int _686388;
_686388 = _686375 + zi_681989;
int _686376;
_686376 = _686375 + _685014;
int _686382;
_686382 = _686375 + _685021;
int _682839;
_682839 = 2 + _682838;
int _687945;
_687945 = 14 * _687944;
int _687975;
_687975 = 14 * _687974;
int _687915;
_687915 = 14 * _687914;
int _687885;
_687885 = 14 * _687884;
int _684259;
_684259 = 2 + _684258;
int _686418;
_686418 = _686405 + zi_681989;
int _686406;
_686406 = _686405 + _685014;
int _686412;
_686412 = _686405 + _685021;
int _683847;
_683847 = _683834 + zi_681989;
int _683841;
_683841 = _683834 + _681997;
int _683243;
_683243 = _683230 + zi_681989;
int _683237;
_683237 = _683230 + _681997;
int _684408;
_684408 = 14 * _684407;
int _684468;
_684468 = 14 * _684467;
int _684528;
_684528 = 14 * _684527;
int _683079;
_683079 = 14 * _683078;
int _683049;
_683049 = 14 * _683048;
int _683169;
_683169 = 14 * _683168;
int _683545;
_683545 = _683532 + zi_681989;
int _683539;
_683539 = _683532 + _681997;
int _685602;
_685602 = _685589 + zi_681989;
int _685590;
_685590 = _685589 + _685014;
int _685596;
_685596 = _685589 + _685021;
int _683269;
_683269 = 2 * _683268;
int _685572;
_685572 = _685559 + zi_681989;
int _685560;
_685560 = _685559 + _685014;
int _685566;
_685566 = _685559 + _685021;
int _685995;
_685995 = _685982 + zi_681989;
int _685983;
_685983 = _685982 + _685014;
int _685989;
_685989 = _685982 + _685021;
int _683122;
_683122 = _683109 + zi_681989;
int _683116;
_683116 = _683109 + _681997;
int _684662;
_684662 = _684649 + zi_681989;
int _684656;
_684656 = _684649 + _681997;
int _687747;
_687747 = _687734 + zi_681989;
int _687735;
_687735 = _687734 + _685014;
int _687741;
_687741 = _687734 + _685021;
int _683696;
_683696 = _683683 + zi_681989;
int _683690;
_683690 = _683683 + _681997;
int _682125;
_682125 = _682112 + zi_681989;
int _682119;
_682119 = _682112 + _681997;
int _682065;
_682065 = _682052 + zi_681989;
int _682059;
_682059 = _682052 + _681997;
int _682669;
_682669 = _682656 + zi_681989;
int _682663;
_682663 = _682656 + _681997;
int _683666;
_683666 = _683653 + zi_681989;
int _683660;
_683660 = _683653 + _681997;
int _687324;
_687324 = _687311 + zi_681989;
int _687312;
_687312 = _687311 + _685014;
int _687318;
_687318 = _687311 + _685021;
int _682862;
_682862 = 2 * _682861;
int _682857;
_682857 = 2 * _682856;
int _686297;
_686297 = _686284 + zi_681989;
int _686285;
_686285 = _686284 + _685014;
int _686291;
_686291 = _686284 + _685021;
int _682427;
_682427 = _682414 + zi_681989;
int _682421;
_682421 = _682414 + _681997;
int _684688;
_684688 = 2 * _684687;
int _682820;
_682820 = _682807 + zi_681989;
int _682814;
_682814 = _682807 + _681997;
int _687643;
_687643 = 14 * _687642;
int _687613;
_687613 = 14 * _687612;
int _687673;
_687673 = 14 * _687672;
int _687583;
_687583 = 14 * _687582;
int _687703;
_687703 = 14 * _687702;
int _685512;
_685512 = _685499 + zi_681989;
int _685500;
_685500 = _685499 + _685014;
int _685506;
_685506 = _685499 + _685021;
int _687354;
_687354 = _687341 + zi_681989;
int _687342;
_687342 = _687341 + _685014;
int _687348;
_687348 = _687341 + _685021;
int _683213;
_683213 = _683200 + zi_681989;
int _683207;
_683207 = _683200 + _681997;
int _684451;
_684451 = _684438 + zi_681989;
int _684445;
_684445 = _684438 + _681997;
int _683949;
_683949 = 2 * _683948;
int _683944;
_683944 = 2 * _683943;
int _683939;
_683939 = 2 * _683938;
int _687112;
_687112 = _687099 + zi_681989;
int _687100;
_687100 = _687099 + _685014;
int _687106;
_687106 = _687099 + _685021;
int _683285;
_683285 = 2 * _683284;
int _683280;
_683280 = 2 * _683279;
int _683275;
_683275 = 2 * _683274;
float* _684877;
_684877 = _453093_681168 + _684876;
int _686871;
_686871 = _686858 + zi_681989;
int _686859;
_686859 = _686858 + _685014;
int _686865;
_686865 = _686858 + _685021;
int _687173;
_687173 = _687160 + zi_681989;
int _687161;
_687161 = _687160 + _685014;
int _687167;
_687167 = _687160 + _685021;
int _683152;
_683152 = _683139 + zi_681989;
int _683146;
_683146 = _683139 + _681997;
int _685891;
_685891 = 14 * _685890;
int _685771;
_685771 = 14 * _685770;
int _685861;
_685861 = 14 * _685860;
int _685801;
_685801 = 14 * _685800;
int _684813;
_684813 = _684800 + zi_681989;
int _684807;
_684807 = _684800 + _681997;
int _683635;
_683635 = _683622 + zi_681989;
int _683629;
_683629 = _683622 + _681997;
float* _687055;
_687055 = _453093_681168 + _687054;
int _682518;
_682518 = _682505 + zi_681989;
int _682512;
_682512 = _682505 + _681997;
int _687475;
_687475 = _687462 + zi_681989;
int _687463;
_687463 = _687462 + _685014;
int _687469;
_687469 = _687462 + _685021;
int _685663;
_685663 = _685650 + zi_681989;
int _685651;
_685651 = _685650 + _685014;
int _685657;
_685657 = _685650 + _685021;
int _685076;
_685076 = 14 * _685075;
int _685136;
_685136 = 14 * _685135;
int _685106;
_685106 = 14 * _685105;
int _685012;
_685012 = 14 * _685011;
int _685046;
_685046 = 14 * _685045;
float* _687065;
_687065 = _453093_681168 + _687064;
int _684511;
_684511 = _684498 + zi_681989;
int _684505;
_684505 = _684498 + _681997;
int _683381;
_683381 = 14 * _683380;
int _683471;
_683471 = 14 * _683470;
int _683441;
_683441 = 14 * _683440;
int _683351;
_683351 = 14 * _683350;
int _685965;
_685965 = _685952 + zi_681989;
int _685953;
_685953 = _685952 + _685014;
int _685959;
_685959 = _685952 + _685021;
int _685844;
_685844 = _685831 + zi_681989;
int _685832;
_685832 = _685831 + _685014;
int _685838;
_685838 = _685831 + _685021;
float* _682853;
_682853 = _453093_681168 + _682852;
int _683605;
_683605 = _683592 + zi_681989;
int _683599;
_683599 = _683592 + _681997;
int _683786;
_683786 = _683773 + zi_681989;
int _683780;
_683780 = _683773 + _681997;
int _686163;
_686163 = 14 * _686162;
int _686103;
_686103 = 14 * _686102;
int _686073;
_686073 = 14 * _686072;
int _686193;
_686193 = 14 * _686192;
int _686133;
_686133 = 14 * _686132;
int _683424;
_683424 = _683411 + zi_681989;
int _683418;
_683418 = _683411 + _681997;
int _688018;
_688018 = _688005 + zi_681989;
int _688012;
_688012 = _688005 + _685021;
int _688006;
_688006 = _688005 + _685014;
int _687777;
_687777 = _687764 + zi_681989;
int _687765;
_687765 = _687764 + _685014;
int _687771;
_687771 = _687764 + _685021;
float* _682575;
_682575 = _453093_681168 + _682574;
int _686720;
_686720 = _686707 + zi_681989;
int _686708;
_686708 = _686707 + _685014;
int _686714;
_686714 = _686707 + _685021;
int _684196;
_684196 = 14 * _684195;
int _684226;
_684226 = 14 * _684225;
int _684106;
_684106 = 14 * _684105;
int _684166;
_684166 = 14 * _684165;
int _684136;
_684136 = 14 * _684135;
int _683866;
_683866 = 2 + _683865;
int _684870;
_684870 = 2 * _684869;
int _682326;
_682326 = 2 + _682325;
int _683756;
_683756 = _683743 + zi_681989;
int _683750;
_683750 = _683743 + _681997;
int _684783;
_684783 = _684770 + zi_681989;
int _684777;
_684777 = _684770 + _681997;
int _683738;
_683738 = 2 * _683737;
int _683733;
_683733 = 2 * _683732;
int _683728;
_683728 = 2 * _683727;
int _682458;
_682458 = _682445 + zi_681989;
int _682452;
_682452 = _682445 + _681997;
int _686901;
_686901 = _686888 + zi_681989;
int _686889;
_686889 = _686888 + _685014;
int _686895;
_686895 = _686888 + _685021;
int _686961;
_686961 = _686948 + zi_681989;
int _686949;
_686949 = _686948 + _685014;
int _686955;
_686955 = _686948 + _685021;
int _686931;
_686931 = _686918 + zi_681989;
int _686919;
_686919 = _686918 + _685014;
int _686925;
_686925 = _686918 + _685021;
int _686478;
_686478 = _686465 + zi_681989;
int _686466;
_686466 = _686465 + _685014;
int _686472;
_686472 = _686465 + _685021;
int _683817;
_683817 = _683804 + zi_681989;
int _683811;
_683811 = _683804 + _681997;
int _687233;
_687233 = _687220 + zi_681989;
int _687221;
_687221 = _687220 + _685014;
int _687227;
_687227 = _687220 + _685021;
int _687263;
_687263 = _687250 + zi_681989;
int _687251;
_687251 = _687250 + _685014;
int _687257;
_687257 = _687250 + _685021;
int _687203;
_687203 = _687190 + zi_681989;
int _687191;
_687191 = _687190 + _685014;
int _687197;
_687197 = _687190 + _685021;
int _684572;
_684572 = _684559 + zi_681989;
int _684566;
_684566 = _684559 + _681997;
int _684994;
_684994 = _684981 + zi_681989;
int _684988;
_684988 = _684981 + _681997;
int _684904;
_684904 = _684891 + zi_681989;
int _684898;
_684898 = _684891 + _681997;
int _682537;
_682537 = 2 + _682536;
int _687565;
_687565 = _687552 + zi_681989;
int _687553;
_687553 = _687552 + _685014;
int _687559;
_687559 = _687552 + _685021;
int _684614;
_684614 = 2 * _684613;
int _684609;
_684609 = 2 * _684608;
int _684604;
_684604 = 2 * _684603;
int _684598;
_684598 = 2 * _684597;
int _685693;
_685693 = _685680 + zi_681989;
int _685681;
_685681 = _685680 + _685014;
int _685687;
_685687 = _685680 + _685021;
int _685723;
_685723 = _685710 + zi_681989;
int _685711;
_685711 = _685710 + _685014;
int _685717;
_685717 = _685710 + _685021;
int _686780;
_686780 = _686767 + zi_681989;
int _686768;
_686768 = _686767 + _685014;
int _686774;
_686774 = _686767 + _685021;
int _686690;
_686690 = _686677 + zi_681989;
int _686678;
_686678 = _686677 + _685014;
int _686684;
_686684 = _686677 + _685021;
int _686659;
_686659 = _686646 + zi_681989;
int _686647;
_686647 = _686646 + _685014;
int _686653;
_686653 = _686646 + _685021;
int _686599;
_686599 = _686586 + zi_681989;
int _686587;
_686587 = _686586 + _685014;
int _686593;
_686593 = _686586 + _685021;
int _686569;
_686569 = _686556 + zi_681989;
int _686557;
_686557 = _686556 + _685014;
int _686563;
_686563 = _686556 + _685021;
int _686019;
_686019 = _686012 + _685021;
int _685868;
_685868 = _685861 + _685021;
int _685083;
_685083 = _685076 + _685021;
int _687650;
_687650 = _687643 + _685021;
int _685929;
_685929 = _685922 + _685021;
int _687982;
_687982 = _687975 + _685021;
int _686080;
_686080 = _686073 + _685021;
int _685808;
_685808 = _685801 + _685021;
int _687076;
_687076 = _687069 + _685021;
int _687861;
_687861 = _687854 + _685021;
int _687922;
_687922 = _687915 + _685021;
int _685053;
_685053 = _685046 + _685021;
int _687137;
_687137 = _687130 + _685021;
int _687952;
_687952 = _687945 + _685021;
int _685113;
_685113 = _685106 + _685021;
int _685536;
_685536 = _685529 + _685021;
int _687892;
_687892 = _687885 + _685021;
int _687288;
_687288 = _687281 + _685021;
int _685415;
_685415 = _685408 + _685021;
int _687046;
_687046 = _687039 + _685021;
int _685234;
_685234 = _685227 + _685021;
int _686321;
_686321 = _686314 + _685021;
int _686170;
_686170 = _686163 + _685021;
int _686140;
_686140 = _686133 + _685021;
int _686835;
_686835 = _686828 + _685021;
int _685627;
_685627 = _685620 + _685021;
int _685143;
_685143 = _685136 + _685021;
int _687620;
_687620 = _687613 + _685021;
int _687408;
_687408 = _687401 + _685021;
int _687831;
_687831 = _687824 + _685021;
int _687590;
_687590 = _687583 + _685021;
int _687801;
_687801 = _687794 + _685021;
int _687680;
_687680 = _687673 + _685021;
int _685325;
_685325 = _685318 + _685021;
int _687378;
_687378 = _687371 + _685021;
int _686110;
_686110 = _686103 + _685021;
int _685355;
_685355 = _685348 + _685021;
int _685778;
_685778 = _685771 + _685021;
int _686351;
_686351 = _686344 + _685021;
int _686200;
_686200 = _686193 + _685021;
int _685445;
_685445 = _685438 + _685021;
int _686533;
_686533 = _686526 + _685021;
int _685174;
_685174 = _685167 + _685021;
int _685747;
_685747 = _685740 + _685021;
int _685385;
_685385 = _685378 + _685021;
int _686231;
_686231 = _686224 + _685021;
int _687710;
_687710 = _687703 + _685021;
int _685898;
_685898 = _685891 + _685021;
int _686261;
_686261 = _686254 + _685021;
int _685022;
_685022 = _685012 + _685021;
int _686986;
_686986 = _686979 + _685021;
int _685294;
_685294 = _685287 + _685021;
int _686049;
_686049 = _686042 + _685021;
int _686315;
_686315 = _686314 + _685014;
int _685168;
_685168 = _685167 + _685014;
int _687584;
_687584 = _687583 + _685014;
int _687131;
_687131 = _687130 + _685014;
int _687282;
_687282 = _687281 + _685014;
int _687674;
_687674 = _687673 + _685014;
int _686829;
_686829 = _686828 + _685014;
int _685288;
_685288 = _685287 + _685014;
int _685047;
_685047 = _685046 + _685014;
int _685741;
_685741 = _685740 + _685014;
int _685862;
_685862 = _685861 + _685014;
int _685349;
_685349 = _685348 + _685014;
int _685621;
_685621 = _685620 + _685014;
int _685107;
_685107 = _685106 + _685014;
int _687855;
_687855 = _687854 + _685014;
int _687614;
_687614 = _687613 + _685014;
int _686225;
_686225 = _686224 + _685014;
int _686134;
_686134 = _686133 + _685014;
int _686013;
_686013 = _686012 + _685014;
int _685137;
_685137 = _685136 + _685014;
int _686527;
_686527 = _686526 + _685014;
int _685228;
_685228 = _685227 + _685014;
int _685892;
_685892 = _685891 + _685014;
int _686043;
_686043 = _686042 + _685014;
int _687946;
_687946 = _687945 + _685014;
int _685439;
_685439 = _685438 + _685014;
int _687040;
_687040 = _687039 + _685014;
int _686104;
_686104 = _686103 + _685014;
int _687070;
_687070 = _687069 + _685014;
int _685015;
_685015 = _685012 + _685014;
int _686194;
_686194 = _686193 + _685014;
int _686164;
_686164 = _686163 + _685014;
int _686074;
_686074 = _686073 + _685014;
int _687825;
_687825 = _687824 + _685014;
int _686345;
_686345 = _686344 + _685014;
int _687916;
_687916 = _687915 + _685014;
int _687976;
_687976 = _687975 + _685014;
int _686255;
_686255 = _686254 + _685014;
int _685802;
_685802 = _685801 + _685014;
int _685409;
_685409 = _685408 + _685014;
int _685077;
_685077 = _685076 + _685014;
int _687795;
_687795 = _687794 + _685014;
int _685379;
_685379 = _685378 + _685014;
int _687644;
_687644 = _687643 + _685014;
int _687372;
_687372 = _687371 + _685014;
int _687402;
_687402 = _687401 + _685014;
int _685923;
_685923 = _685922 + _685014;
int _685319;
_685319 = _685318 + _685014;
int _685772;
_685772 = _685771 + _685014;
int _686980;
_686980 = _686979 + _685014;
int _687704;
_687704 = _687703 + _685014;
int _687886;
_687886 = _687885 + _685014;
int _685530;
_685530 = _685529 + _685014;
int _685645;
_685645 = 2 * _685644;
int _685640;
_685640 = 2 * _685639;
int _685635;
_685635 = 2 * _685634;
int _682802;
_682802 = 2 * _682801;
int _682797;
_682797 = 2 * _682796;
int _682792;
_682792 = 2 * _682791;
int _682379;
_682379 = 2 * _682378;
int _682374;
_682374 = 2 * _682373;
int _682369;
_682369 = 2 * _682368;
int _684704;
_684704 = 2 * _684703;
int _684699;
_684699 = 2 * _684698;
int _684694;
_684694 = 2 * _684693;
int _684282;
_684282 = 2 * _684281;
int _684277;
_684277 = 2 * _684276;
int _684272;
_684272 = 2 * _684271;
int _685554;
_685554 = 2 * _685553;
int _685549;
_685549 = 2 * _685548;
int _685544;
_685544 = 2 * _685543;
int _684855;
_684855 = 2 * _684854;
int _684850;
_684850 = 2 * _684849;
int _684845;
_684845 = 2 * _684844;
int _684983;
_684983 = 2 + _684982;
int _684651;
_684651 = 2 + _684650;
int _684289;
_684289 = 2 + _684288;
int _684712;
_684712 = 2 + _684711;
int _683745;
_683745 = 2 + _683744;
int _684923;
_684923 = 2 + _684922;
int _682114;
_682114 = 2 + _682113;
int _683775;
_683775 = 2 + _683774;
int _683504;
_683504 = 2 + _683503;
int _682054;
_682054 = 2 + _682053;
int _682658;
_682658 = 2 + _682657;
int _684440;
_684440 = 2 + _684439;
int _682507;
_682507 = 2 + _682506;
int _683624;
_683624 = 2 + _683623;
int _684591;
_684591 = 2 + _684590;
int _684621;
_684621 = 2 + _684620;
int _684772;
_684772 = 2 + _684771;
int _684561;
_684561 = 2 + _684560;
int _683141;
_683141 = 2 + _683140;
int _683534;
_683534 = 2 + _683533;
int _683655;
_683655 = 2 + _683654;
int _683322;
_683322 = 2 + _683321;
int _683564;
_683564 = 2 + _683563;
int _683232;
_683232 = 2 + _683231;
int _684953;
_684953 = 2 + _684952;
int _683111;
_683111 = 2 + _683110;
int _683806;
_683806 = 2 + _683805;
int _683202;
_683202 = 2 + _683201;
int _683685;
_683685 = 2 + _683684;
int _682809;
_682809 = 2 + _682808;
int _682477;
_682477 = 2 + _682476;
int _683715;
_683715 = 2 + _683714;
int _684893;
_684893 = 2 + _684892;
int _684349;
_684349 = 2 + _684348;
int _683413;
_683413 = 2 + _683412;
int _682416;
_682416 = 2 + _682415;
int _683836;
_683836 = 2 + _683835;
int _684802;
_684802 = 2 + _684801;
int _682447;
_682447 = 2 + _682446;
int _683594;
_683594 = 2 + _683593;
int _684500;
_684500 = 2 + _684499;
int _687004;
_687004 = 2 * _687003;
int _686999;
_686999 = 2 * _686998;
int _686994;
_686994 = 2 * _686993;
int _683889;
_683889 = 2 * _683888;
int _683884;
_683884 = 2 * _683883;
int _683879;
_683879 = 2 * _683878;
int _687094;
_687094 = 2 * _687093;
int _687089;
_687089 = 2 * _687088;
int _687084;
_687084 = 2 * _687083;
int _683315;
_683315 = 2 * _683314;
int _683310;
_683310 = 2 * _683309;
int _683305;
_683305 = 2 * _683304;
int _683919;
_683919 = 2 * _683918;
int _683914;
_683914 = 2 * _683913;
int _683909;
_683909 = 2 * _683908;
int _682590;
_682590 = 2 * _682589;
int _682585;
_682585 = 2 * _682584;
int _682580;
_682580 = 2 * _682579;
int _686551;
_686551 = 2 * _686550;
int _686546;
_686546 = 2 * _686545;
int _686541;
_686541 = 2 * _686540;
int _687155;
_687155 = 2 * _687154;
int _687150;
_687150 = 2 * _687149;
int _687145;
_687145 = 2 * _687144;
int _685765;
_685765 = 2 * _685764;
int _685760;
_685760 = 2 * _685759;
int _685755;
_685755 = 2 * _685754;
int _682349;
_682349 = 2 * _682348;
int _682344;
_682344 = 2 * _682343;
int _682339;
_682339 = 2 * _682338;
int _682560;
_682560 = 2 * _682559;
int _682555;
_682555 = 2 * _682554;
int _682550;
_682550 = 2 * _682549;
int _687033;
_687033 = 5 + _687022;
int _687028;
_687028 = 4 + _687022;
int _687023;
_687023 = 3 + _687022;
int _687011;
_687011 = 2 + _687010;
int _687017;
_687017 = 2 + _687016;
int _683586;
_683586 = 4 + _683575;
int _683581;
_683581 = 3 + _683575;
int _683576;
_683576 = 2 + _683575;
int _682568;
_682568 = 2 * _682567;
int _683263;
_683263 = 2 * _683262;
int _687456;
_687456 = 5 + _687445;
int _687451;
_687451 = 4 + _687445;
int _687446;
_687446 = 3 + _687445;
int _687434;
_687434 = 2 + _687433;
int _687440;
_687440 = 2 + _687439;
int _684864;
_684864 = 2 * _684863;
float* _687060;
_687060 = _453093_681168 + _687059;
int _683968;
_683968 = _683955 + zi_681989;
int _683956;
_683956 = _683955 + _681990;
int _683962;
_683962 = _683955 + _681997;
int _683998;
_683998 = _683985 + zi_681989;
int _683986;
_683986 = _683985 + _681990;
int _683992;
_683992 = _683985 + _681997;
int _684028;
_684028 = _684015 + zi_681989;
int _684016;
_684016 = _684015 + _681990;
int _684022;
_684022 = _684015 + _681997;
int _684088;
_684088 = _684075 + zi_681989;
int _684076;
_684076 = _684075 + _681990;
int _684082;
_684082 = _684075 + _681997;
int _684058;
_684058 = _684045 + zi_681989;
int _684046;
_684046 = _684045 + _681990;
int _684052;
_684052 = _684045 + _681997;
int _685493;
_685493 = 5 + _685482;
int _685488;
_685488 = 4 + _685482;
int _685483;
_685483 = 3 + _685482;
int _685471;
_685471 = 2 + _685470;
int _685477;
_685477 = 2 + _685476;
int _685300;
_685300 = _685287 + zi_681989;
int _685240;
_685240 = _685227 + zi_681989;
int _685180;
_685180 = _685167 + zi_681989;
int _684330;
_684330 = _684317 + zi_681989;
int _684318;
_684318 = _684317 + _681990;
int _684324;
_684324 = _684317 + _681997;
int _684390;
_684390 = _684377 + zi_681989;
int _684378;
_684378 = _684377 + _681990;
int _684384;
_684384 = _684377 + _681997;
int _682760;
_682760 = _682747 + zi_681989;
int _682748;
_682748 = _682747 + _681990;
int _682754;
_682754 = _682747 + _681997;
int _682880;
_682880 = _682867 + zi_681989;
int _682868;
_682868 = _682867 + _681990;
int _682874;
_682874 = _682867 + _681997;
int _685221;
_685221 = 5 + _685210;
int _685216;
_685216 = 4 + _685210;
int _685211;
_685211 = 3 + _685210;
int _685199;
_685199 = 2 + _685198;
int _685205;
_685205 = 2 + _685204;
float* _686854;
_686854 = _453093_681168 + _686853;
float* _686849;
_686849 = _453093_681168 + _686848;
float* _686844;
_686844 = _453093_681168 + _686843;
int _684311;
_684311 = 4 + _684300;
int _684306;
_684306 = 3 + _684300;
int _684301;
_684301 = 2 + _684300;
int _684643;
_684643 = 4 + _684632;
int _684638;
_684638 = 3 + _684632;
int _684633;
_684633 = 2 + _684632;
int _687294;
_687294 = _687281 + zi_681989;
int _687384;
_687384 = _687371 + zi_681989;
int _687414;
_687414 = _687401 + zi_681989;
int _684743;
_684743 = 2 * _684742;
int _684749;
_684749 = 2 * _684748;
int _686821;
_686821 = 5 + _686810;
int _686816;
_686816 = 4 + _686810;
int _686811;
_686811 = 3 + _686810;
int _686799;
_686799 = 2 + _686798;
int _686805;
_686805 = 2 + _686804;
int _683344;
_683344 = 4 + _683333;
int _683339;
_683339 = 3 + _683333;
int _683334;
_683334 = 2 + _683333;
int _686761;
_686761 = 5 + _686750;
int _686756;
_686756 = 4 + _686750;
int _686751;
_686751 = 3 + _686750;
int _686739;
_686739 = 2 + _686738;
int _686745;
_686745 = 2 + _686744;
int _686459;
_686459 = 5 + _686448;
int _686454;
_686454 = 4 + _686448;
int _686449;
_686449 = 3 + _686448;
int _686437;
_686437 = 2 + _686436;
int _686443;
_686443 = 2 + _686442;
int _684945;
_684945 = 4 + _684934;
int _684940;
_684940 = 3 + _684934;
int _684935;
_684935 = 2 + _684934;
int _682544;
_682544 = 2 * _682543;
int _683329;
_683329 = 2 * _683328;
int _684628;
_684628 = 2 * _684627;
int _683571;
_683571 = 2 * _683570;
int _683933;
_683933 = 2 * _683932;
int _684930;
_684930 = 2 * _684929;
int _683873;
_683873 = 2 * _683872;
int _682846;
_682846 = 2 * _682845;
int _684296;
_684296 = 2 * _684295;
int _682363;
_682363 = 2 * _682362;
int _683299;
_683299 = 2 * _683298;
int _682333;
_682333 = 2 * _682332;
int _684839;
_684839 = 2 * _684838;
int _684266;
_684266 = 2 * _684265;
int _683903;
_683903 = 2 * _683902;
int _682397;
_682397 = _682384 + zi_681989;
int _682385;
_682385 = _682384 + _681990;
int _682391;
_682391 = _682384 + _681997;
int _682307;
_682307 = _682294 + zi_681989;
int _682295;
_682295 = _682294 + _681990;
int _682301;
_682301 = _682294 + _681997;
int _684371;
_684371 = 4 + _684360;
int _684366;
_684366 = 3 + _684360;
int _684361;
_684361 = 2 + _684360;
int _684355;
_684355 = 2 + _684354;
int _683293;
_683293 = 2 * _683292;
int _687546;
_687546 = 5 + _687535;
int _687541;
_687541 = 4 + _687535;
int _687536;
_687536 = 3 + _687535;
int _687524;
_687524 = 2 + _687523;
int _687530;
_687530 = 2 + _687529;
int _686519;
_686519 = 5 + _686508;
int _686514;
_686514 = 4 + _686508;
int _686509;
_686509 = 3 + _686508;
int _686497;
_686497 = 2 + _686496;
int _686503;
_686503 = 2 + _686502;
int _685331;
_685331 = _685318 + zi_681989;
int _685391;
_685391 = _685378 + zi_681989;
int _685421;
_685421 = _685408 + zi_681989;
int _685361;
_685361 = _685348 + zi_681989;
int _685451;
_685451 = _685438 + zi_681989;
int _684833;
_684833 = 2 * _684832;
int _682216;
_682216 = _682203 + zi_681989;
int _682204;
_682204 = _682203 + _681990;
int _682210;
_682210 = _682203 + _681997;
int _682276;
_682276 = _682263 + zi_681989;
int _682264;
_682264 = _682263 + _681990;
int _682270;
_682270 = _682263 + _681997;
int _682246;
_682246 = _682233 + zi_681989;
int _682234;
_682234 = _682233 + _681990;
int _682240;
_682240 = _682233 + _681997;
int _682186;
_682186 = _682173 + zi_681989;
int _682174;
_682174 = _682173 + _681990;
int _682180;
_682180 = _682173 + _681997;
int _682156;
_682156 = _682143 + zi_681989;
int _682144;
_682144 = _682143 + _681990;
int _682150;
_682150 = _682143 + _681997;
int _683001;
_683001 = _682988 + zi_681989;
int _682989;
_682989 = _682988 + _681990;
int _682995;
_682995 = _682988 + _681997;
int _682941;
_682941 = _682928 + zi_681989;
int _682929;
_682929 = _682928 + _681990;
int _682935;
_682935 = _682928 + _681997;
int _682911;
_682911 = _682898 + zi_681989;
int _682899;
_682899 = _682898 + _681990;
int _682905;
_682905 = _682898 + _681997;
int _682971;
_682971 = _682958 + zi_681989;
int _682959;
_682959 = _682958 + _681990;
int _682965;
_682965 = _682958 + _681997;
int _683031;
_683031 = _683018 + zi_681989;
int _683019;
_683019 = _683018 + _681990;
int _683025;
_683025 = _683018 + _681997;
float* _684887;
_684887 = _453093_681168 + _684886;
float* _684882;
_684882 = _453093_681168 + _684881;
int _683927;
_683927 = 2 * _683926;
int _684682;
_684682 = 2 * _684681;
int _684734;
_684734 = 4 + _684723;
int _684729;
_684729 = 3 + _684723;
int _684724;
_684724 = 2 + _684723;
int _684718;
_684718 = 2 + _684717;
int _682499;
_682499 = 4 + _682488;
int _682494;
_682494 = 3 + _682488;
int _682489;
_682489 = 2 + _682488;
int _682483;
_682483 = 2 + _682482;
int _686327;
_686327 = _686314 + zi_681989;
int _686237;
_686237 = _686224 + zi_681989;
int _686357;
_686357 = _686344 + zi_681989;
int _686267;
_686267 = _686254 + zi_681989;
int _682357;
_682357 = 2 * _682356;
int _683897;
_683897 = 2 * _683896;
int _683526;
_683526 = 4 + _683515;
int _683521;
_683521 = 3 + _683515;
int _683516;
_683516 = 2 + _683515;
int _683510;
_683510 = 2 + _683509;
int _682729;
_682729 = _682716 + zi_681989;
int _682717;
_682717 = _682716 + _681990;
int _682723;
_682723 = _682716 + _681997;
int _682609;
_682609 = _682596 + zi_681989;
int _682597;
_682597 = _682596 + _681990;
int _682603;
_682603 = _682596 + _681997;
int _682699;
_682699 = _682686 + zi_681989;
int _682687;
_682687 = _682686 + _681990;
int _682693;
_682693 = _682686 + _681997;
int _682639;
_682639 = _682626 + zi_681989;
int _682627;
_682627 = _682626 + _681990;
int _682633;
_682633 = _682626 + _681997;
int _685281;
_685281 = 5 + _685270;
int _685276;
_685276 = 4 + _685270;
int _685271;
_685271 = 3 + _685270;
int _685259;
_685259 = 2 + _685258;
int _685265;
_685265 = 2 + _685264;
int _687837;
_687837 = _687824 + zi_681989;
int _687867;
_687867 = _687854 + zi_681989;
int _687807;
_687807 = _687794 + zi_681989;
int _687516;
_687516 = 5 + _687505;
int _687511;
_687511 = 4 + _687505;
int _687506;
_687506 = 3 + _687505;
int _687494;
_687494 = 2 + _687493;
int _687500;
_687500 = 2 + _687499;
float* _683723;
_683723 = _453093_681168 + _683722;
int _686640;
_686640 = 5 + _686629;
int _686635;
_686635 = 4 + _686629;
int _686630;
_686630 = 3 + _686629;
int _686618;
_686618 = 2 + _686617;
int _686624;
_686624 = 2 + _686623;
float* _684766;
_684766 = _453093_681168 + _684765;
float* _684761;
_684761 = _453093_681168 + _684760;
int _682780;
_682780 = 2 * _682779;
int _684975;
_684975 = 4 + _684964;
int _684970;
_684970 = 3 + _684964;
int _684965;
_684965 = 2 + _684964;
int _684959;
_684959 = 2 + _684958;
int _682095;
_682095 = _682082 + zi_681989;
int _682083;
_682083 = _682082 + _681990;
int _682089;
_682089 = _682082 + _681997;
int _682035;
_682035 = _682022 + zi_681989;
int _682023;
_682023 = _682022 + _681990;
int _682029;
_682029 = _682022 + _681997;
int _682004;
_682004 = _681986 + zi_681989;
int _681991;
_681991 = _681986 + _681990;
int _681998;
_681998 = _681986 + _681997;
float* _682787;
_682787 = _453093_681168 + _682786;
int _686025;
_686025 = _686012 + zi_681989;
int _685935;
_685935 = _685922 + zi_681989;
int _686055;
_686055 = _686042 + zi_681989;
int _686399;
_686399 = 5 + _686388;
int _686394;
_686394 = 4 + _686388;
int _686389;
_686389 = 3 + _686388;
int _686377;
_686377 = 2 + _686376;
int _686383;
_686383 = 2 + _686382;
int _682840;
_682840 = 2 * _682839;
int _687958;
_687958 = _687945 + zi_681989;
int _687988;
_687988 = _687975 + zi_681989;
int _687928;
_687928 = _687915 + zi_681989;
int _687898;
_687898 = _687885 + zi_681989;
int _684260;
_684260 = 2 * _684259;
int _686429;
_686429 = 5 + _686418;
int _686424;
_686424 = 4 + _686418;
int _686419;
_686419 = 3 + _686418;
int _686407;
_686407 = 2 + _686406;
int _686413;
_686413 = 2 + _686412;
int _683858;
_683858 = 4 + _683847;
int _683853;
_683853 = 3 + _683847;
int _683848;
_683848 = 2 + _683847;
int _683842;
_683842 = 2 + _683841;
int _683254;
_683254 = 4 + _683243;
int _683249;
_683249 = 3 + _683243;
int _683244;
_683244 = 2 + _683243;
int _683238;
_683238 = 2 + _683237;
int _684421;
_684421 = _684408 + zi_681989;
int _684409;
_684409 = _684408 + _681990;
int _684415;
_684415 = _684408 + _681997;
int _684481;
_684481 = _684468 + zi_681989;
int _684469;
_684469 = _684468 + _681990;
int _684475;
_684475 = _684468 + _681997;
int _684541;
_684541 = _684528 + zi_681989;
int _684529;
_684529 = _684528 + _681990;
int _684535;
_684535 = _684528 + _681997;
int _683092;
_683092 = _683079 + zi_681989;
int _683080;
_683080 = _683079 + _681990;
int _683086;
_683086 = _683079 + _681997;
int _683062;
_683062 = _683049 + zi_681989;
int _683050;
_683050 = _683049 + _681990;
int _683056;
_683056 = _683049 + _681997;
int _683182;
_683182 = _683169 + zi_681989;
int _683170;
_683170 = _683169 + _681990;
int _683176;
_683176 = _683169 + _681997;
int _683556;
_683556 = 4 + _683545;
int _683551;
_683551 = 3 + _683545;
int _683546;
_683546 = 2 + _683545;
int _683540;
_683540 = 2 + _683539;
int _685613;
_685613 = 5 + _685602;
int _685608;
_685608 = 4 + _685602;
int _685603;
_685603 = 3 + _685602;
int _685591;
_685591 = 2 + _685590;
int _685597;
_685597 = 2 + _685596;
float* _683270;
_683270 = _453093_681168 + _683269;
int _685583;
_685583 = 5 + _685572;
int _685578;
_685578 = 4 + _685572;
int _685573;
_685573 = 3 + _685572;
int _685561;
_685561 = 2 + _685560;
int _685567;
_685567 = 2 + _685566;
int _686006;
_686006 = 5 + _685995;
int _686001;
_686001 = 4 + _685995;
int _685996;
_685996 = 3 + _685995;
int _685984;
_685984 = 2 + _685983;
int _685990;
_685990 = 2 + _685989;
int _683133;
_683133 = 4 + _683122;
int _683128;
_683128 = 3 + _683122;
int _683123;
_683123 = 2 + _683122;
int _683117;
_683117 = 2 + _683116;
int _684673;
_684673 = 4 + _684662;
int _684668;
_684668 = 3 + _684662;
int _684663;
_684663 = 2 + _684662;
int _684657;
_684657 = 2 + _684656;
int _687758;
_687758 = 5 + _687747;
int _687753;
_687753 = 4 + _687747;
int _687748;
_687748 = 3 + _687747;
int _687736;
_687736 = 2 + _687735;
int _687742;
_687742 = 2 + _687741;
int _683707;
_683707 = 4 + _683696;
int _683702;
_683702 = 3 + _683696;
int _683697;
_683697 = 2 + _683696;
int _683691;
_683691 = 2 + _683690;
int _682136;
_682136 = 4 + _682125;
int _682131;
_682131 = 3 + _682125;
int _682126;
_682126 = 2 + _682125;
int _682120;
_682120 = 2 + _682119;
int _682076;
_682076 = 4 + _682065;
int _682071;
_682071 = 3 + _682065;
int _682066;
_682066 = 2 + _682065;
int _682060;
_682060 = 2 + _682059;
int _682680;
_682680 = 4 + _682669;
int _682675;
_682675 = 3 + _682669;
int _682670;
_682670 = 2 + _682669;
int _682664;
_682664 = 2 + _682663;
int _683677;
_683677 = 4 + _683666;
int _683672;
_683672 = 3 + _683666;
int _683667;
_683667 = 2 + _683666;
int _683661;
_683661 = 2 + _683660;
int _687335;
_687335 = 5 + _687324;
int _687330;
_687330 = 4 + _687324;
int _687325;
_687325 = 3 + _687324;
int _687313;
_687313 = 2 + _687312;
int _687319;
_687319 = 2 + _687318;
float* _682863;
_682863 = _453093_681168 + _682862;
float* _682858;
_682858 = _453093_681168 + _682857;
int _686308;
_686308 = 5 + _686297;
int _686303;
_686303 = 4 + _686297;
int _686298;
_686298 = 3 + _686297;
int _686286;
_686286 = 2 + _686285;
int _686292;
_686292 = 2 + _686291;
int _682438;
_682438 = 4 + _682427;
int _682433;
_682433 = 3 + _682427;
int _682428;
_682428 = 2 + _682427;
int _682422;
_682422 = 2 + _682421;
float* _684689;
_684689 = _453093_681168 + _684688;
int _682831;
_682831 = 4 + _682820;
int _682826;
_682826 = 3 + _682820;
int _682821;
_682821 = 2 + _682820;
int _682815;
_682815 = 2 + _682814;
int _687656;
_687656 = _687643 + zi_681989;
int _687626;
_687626 = _687613 + zi_681989;
int _687686;
_687686 = _687673 + zi_681989;
int _687596;
_687596 = _687583 + zi_681989;
int _687716;
_687716 = _687703 + zi_681989;
int _685523;
_685523 = 5 + _685512;
int _685518;
_685518 = 4 + _685512;
int _685513;
_685513 = 3 + _685512;
int _685501;
_685501 = 2 + _685500;
int _685507;
_685507 = 2 + _685506;
int _687365;
_687365 = 5 + _687354;
int _687360;
_687360 = 4 + _687354;
int _687355;
_687355 = 3 + _687354;
int _687343;
_687343 = 2 + _687342;
int _687349;
_687349 = 2 + _687348;
int _683224;
_683224 = 4 + _683213;
int _683219;
_683219 = 3 + _683213;
int _683214;
_683214 = 2 + _683213;
int _683208;
_683208 = 2 + _683207;
int _684462;
_684462 = 4 + _684451;
int _684457;
_684457 = 3 + _684451;
int _684452;
_684452 = 2 + _684451;
int _684446;
_684446 = 2 + _684445;
float* _683950;
_683950 = _453093_681168 + _683949;
float* _683945;
_683945 = _453093_681168 + _683944;
float* _683940;
_683940 = _453093_681168 + _683939;
int _687123;
_687123 = 5 + _687112;
int _687118;
_687118 = 4 + _687112;
int _687113;
_687113 = 3 + _687112;
int _687101;
_687101 = 2 + _687100;
int _687107;
_687107 = 2 + _687106;
float* _683286;
_683286 = _453093_681168 + _683285;
float* _683281;
_683281 = _453093_681168 + _683280;
float* _683276;
_683276 = _453093_681168 + _683275;
int _686882;
_686882 = 5 + _686871;
int _686877;
_686877 = 4 + _686871;
int _686872;
_686872 = 3 + _686871;
int _686860;
_686860 = 2 + _686859;
int _686866;
_686866 = 2 + _686865;
int _687184;
_687184 = 5 + _687173;
int _687179;
_687179 = 4 + _687173;
int _687174;
_687174 = 3 + _687173;
int _687162;
_687162 = 2 + _687161;
int _687168;
_687168 = 2 + _687167;
int _683163;
_683163 = 4 + _683152;
int _683158;
_683158 = 3 + _683152;
int _683153;
_683153 = 2 + _683152;
int _683147;
_683147 = 2 + _683146;
int _685904;
_685904 = _685891 + zi_681989;
int _685784;
_685784 = _685771 + zi_681989;
int _685874;
_685874 = _685861 + zi_681989;
int _685814;
_685814 = _685801 + zi_681989;
int _684824;
_684824 = 4 + _684813;
int _684819;
_684819 = 3 + _684813;
int _684814;
_684814 = 2 + _684813;
int _684808;
_684808 = 2 + _684807;
int _683646;
_683646 = 4 + _683635;
int _683641;
_683641 = 3 + _683635;
int _683636;
_683636 = 2 + _683635;
int _683630;
_683630 = 2 + _683629;
int _682529;
_682529 = 4 + _682518;
int _682524;
_682524 = 3 + _682518;
int _682519;
_682519 = 2 + _682518;
int _682513;
_682513 = 2 + _682512;
int _687486;
_687486 = 5 + _687475;
int _687481;
_687481 = 4 + _687475;
int _687476;
_687476 = 3 + _687475;
int _687464;
_687464 = 2 + _687463;
int _687470;
_687470 = 2 + _687469;
int _685674;
_685674 = 5 + _685663;
int _685669;
_685669 = 4 + _685663;
int _685664;
_685664 = 3 + _685663;
int _685652;
_685652 = 2 + _685651;
int _685658;
_685658 = 2 + _685657;
int _685089;
_685089 = _685076 + zi_681989;
int _685149;
_685149 = _685136 + zi_681989;
int _685119;
_685119 = _685106 + zi_681989;
int _685028;
_685028 = _685012 + zi_681989;
int _685059;
_685059 = _685046 + zi_681989;
int _684522;
_684522 = 4 + _684511;
int _684517;
_684517 = 3 + _684511;
int _684512;
_684512 = 2 + _684511;
int _684506;
_684506 = 2 + _684505;
int _683394;
_683394 = _683381 + zi_681989;
int _683382;
_683382 = _683381 + _681990;
int _683388;
_683388 = _683381 + _681997;
int _683484;
_683484 = _683471 + zi_681989;
int _683472;
_683472 = _683471 + _681990;
int _683478;
_683478 = _683471 + _681997;
int _683454;
_683454 = _683441 + zi_681989;
int _683442;
_683442 = _683441 + _681990;
int _683448;
_683448 = _683441 + _681997;
int _683364;
_683364 = _683351 + zi_681989;
int _683352;
_683352 = _683351 + _681990;
int _683358;
_683358 = _683351 + _681997;
int _685976;
_685976 = 5 + _685965;
int _685971;
_685971 = 4 + _685965;
int _685966;
_685966 = 3 + _685965;
int _685954;
_685954 = 2 + _685953;
int _685960;
_685960 = 2 + _685959;
int _685855;
_685855 = 5 + _685844;
int _685850;
_685850 = 4 + _685844;
int _685845;
_685845 = 3 + _685844;
int _685833;
_685833 = 2 + _685832;
int _685839;
_685839 = 2 + _685838;
int _683616;
_683616 = 4 + _683605;
int _683611;
_683611 = 3 + _683605;
int _683606;
_683606 = 2 + _683605;
int _683600;
_683600 = 2 + _683599;
int _683797;
_683797 = 4 + _683786;
int _683792;
_683792 = 3 + _683786;
int _683787;
_683787 = 2 + _683786;
int _683781;
_683781 = 2 + _683780;
int _686176;
_686176 = _686163 + zi_681989;
int _686116;
_686116 = _686103 + zi_681989;
int _686086;
_686086 = _686073 + zi_681989;
int _686206;
_686206 = _686193 + zi_681989;
int _686146;
_686146 = _686133 + zi_681989;
int _683435;
_683435 = 4 + _683424;
int _683430;
_683430 = 3 + _683424;
int _683425;
_683425 = 2 + _683424;
int _683419;
_683419 = 2 + _683418;
int _688029;
_688029 = 5 + _688018;
int _688024;
_688024 = 4 + _688018;
int _688019;
_688019 = 3 + _688018;
int _688013;
_688013 = 2 + _688012;
int _688007;
_688007 = 2 + _688006;
int _687788;
_687788 = 5 + _687777;
int _687783;
_687783 = 4 + _687777;
int _687778;
_687778 = 3 + _687777;
int _687766;
_687766 = 2 + _687765;
int _687772;
_687772 = 2 + _687771;
int _686731;
_686731 = 5 + _686720;
int _686726;
_686726 = 4 + _686720;
int _686721;
_686721 = 3 + _686720;
int _686709;
_686709 = 2 + _686708;
int _686715;
_686715 = 2 + _686714;
int _684209;
_684209 = _684196 + zi_681989;
int _684197;
_684197 = _684196 + _681990;
int _684203;
_684203 = _684196 + _681997;
int _684239;
_684239 = _684226 + zi_681989;
int _684227;
_684227 = _684226 + _681990;
int _684233;
_684233 = _684226 + _681997;
int _684119;
_684119 = _684106 + zi_681989;
int _684107;
_684107 = _684106 + _681990;
int _684113;
_684113 = _684106 + _681997;
int _684179;
_684179 = _684166 + zi_681989;
int _684167;
_684167 = _684166 + _681990;
int _684173;
_684173 = _684166 + _681997;
int _684149;
_684149 = _684136 + zi_681989;
int _684137;
_684137 = _684136 + _681990;
int _684143;
_684143 = _684136 + _681997;
int _683867;
_683867 = 2 * _683866;
float* _684871;
_684871 = _453093_681168 + _684870;
int _682327;
_682327 = 2 * _682326;
int _683767;
_683767 = 4 + _683756;
int _683762;
_683762 = 3 + _683756;
int _683757;
_683757 = 2 + _683756;
int _683751;
_683751 = 2 + _683750;
int _684794;
_684794 = 4 + _684783;
int _684789;
_684789 = 3 + _684783;
int _684784;
_684784 = 2 + _684783;
int _684778;
_684778 = 2 + _684777;
float* _683739;
_683739 = _453093_681168 + _683738;
float* _683734;
_683734 = _453093_681168 + _683733;
float* _683729;
_683729 = _453093_681168 + _683728;
int _682469;
_682469 = 4 + _682458;
int _682464;
_682464 = 3 + _682458;
int _682459;
_682459 = 2 + _682458;
int _682453;
_682453 = 2 + _682452;
int _686912;
_686912 = 5 + _686901;
int _686907;
_686907 = 4 + _686901;
int _686902;
_686902 = 3 + _686901;
int _686890;
_686890 = 2 + _686889;
int _686896;
_686896 = 2 + _686895;
int _686972;
_686972 = 5 + _686961;
int _686967;
_686967 = 4 + _686961;
int _686962;
_686962 = 3 + _686961;
int _686950;
_686950 = 2 + _686949;
int _686956;
_686956 = 2 + _686955;
int _686942;
_686942 = 5 + _686931;
int _686937;
_686937 = 4 + _686931;
int _686932;
_686932 = 3 + _686931;
int _686920;
_686920 = 2 + _686919;
int _686926;
_686926 = 2 + _686925;
int _686489;
_686489 = 5 + _686478;
int _686484;
_686484 = 4 + _686478;
int _686479;
_686479 = 3 + _686478;
int _686467;
_686467 = 2 + _686466;
int _686473;
_686473 = 2 + _686472;
int _683828;
_683828 = 4 + _683817;
int _683823;
_683823 = 3 + _683817;
int _683818;
_683818 = 2 + _683817;
int _683812;
_683812 = 2 + _683811;
int _687244;
_687244 = 5 + _687233;
int _687239;
_687239 = 4 + _687233;
int _687234;
_687234 = 3 + _687233;
int _687222;
_687222 = 2 + _687221;
int _687228;
_687228 = 2 + _687227;
int _687274;
_687274 = 5 + _687263;
int _687269;
_687269 = 4 + _687263;
int _687264;
_687264 = 3 + _687263;
int _687252;
_687252 = 2 + _687251;
int _687258;
_687258 = 2 + _687257;
int _687214;
_687214 = 5 + _687203;
int _687209;
_687209 = 4 + _687203;
int _687204;
_687204 = 3 + _687203;
int _687192;
_687192 = 2 + _687191;
int _687198;
_687198 = 2 + _687197;
int _684583;
_684583 = 4 + _684572;
int _684578;
_684578 = 3 + _684572;
int _684573;
_684573 = 2 + _684572;
int _684567;
_684567 = 2 + _684566;
int _685005;
_685005 = 4 + _684994;
int _685000;
_685000 = 3 + _684994;
int _684995;
_684995 = 2 + _684994;
int _684989;
_684989 = 2 + _684988;
int _684915;
_684915 = 4 + _684904;
int _684910;
_684910 = 3 + _684904;
int _684905;
_684905 = 2 + _684904;
int _684899;
_684899 = 2 + _684898;
int _682538;
_682538 = 2 * _682537;
int _687576;
_687576 = 5 + _687565;
int _687571;
_687571 = 4 + _687565;
int _687566;
_687566 = 3 + _687565;
int _687554;
_687554 = 2 + _687553;
int _687560;
_687560 = 2 + _687559;
float* _684615;
_684615 = _453093_681168 + _684614;
float* _684610;
_684610 = _453093_681168 + _684609;
float* _684605;
_684605 = _453093_681168 + _684604;
float* _684599;
_684599 = _453093_681168 + _684598;
int _685704;
_685704 = 5 + _685693;
int _685699;
_685699 = 4 + _685693;
int _685694;
_685694 = 3 + _685693;
int _685682;
_685682 = 2 + _685681;
int _685688;
_685688 = 2 + _685687;
int _685734;
_685734 = 5 + _685723;
int _685729;
_685729 = 4 + _685723;
int _685724;
_685724 = 3 + _685723;
int _685712;
_685712 = 2 + _685711;
int _685718;
_685718 = 2 + _685717;
int _686791;
_686791 = 5 + _686780;
int _686786;
_686786 = 4 + _686780;
int _686781;
_686781 = 3 + _686780;
int _686769;
_686769 = 2 + _686768;
int _686775;
_686775 = 2 + _686774;
int _686701;
_686701 = 5 + _686690;
int _686696;
_686696 = 4 + _686690;
int _686691;
_686691 = 3 + _686690;
int _686679;
_686679 = 2 + _686678;
int _686685;
_686685 = 2 + _686684;
int _686670;
_686670 = 5 + _686659;
int _686665;
_686665 = 4 + _686659;
int _686660;
_686660 = 3 + _686659;
int _686648;
_686648 = 2 + _686647;
int _686654;
_686654 = 2 + _686653;
int _686610;
_686610 = 5 + _686599;
int _686605;
_686605 = 4 + _686599;
int _686600;
_686600 = 3 + _686599;
int _686588;
_686588 = 2 + _686587;
int _686594;
_686594 = 2 + _686593;
int _686580;
_686580 = 5 + _686569;
int _686575;
_686575 = 4 + _686569;
int _686570;
_686570 = 3 + _686569;
int _686558;
_686558 = 2 + _686557;
int _686564;
_686564 = 2 + _686563;
int _686020;
_686020 = 2 + _686019;
int _685869;
_685869 = 2 + _685868;
int _685084;
_685084 = 2 + _685083;
int _687651;
_687651 = 2 + _687650;
int _685930;
_685930 = 2 + _685929;
int _687983;
_687983 = 2 + _687982;
int _686081;
_686081 = 2 + _686080;
int _685809;
_685809 = 2 + _685808;
int _687077;
_687077 = 2 + _687076;
int _687862;
_687862 = 2 + _687861;
int _687923;
_687923 = 2 + _687922;
int _685054;
_685054 = 2 + _685053;
int _687138;
_687138 = 2 + _687137;
int _687953;
_687953 = 2 + _687952;
int _685114;
_685114 = 2 + _685113;
int _685537;
_685537 = 2 + _685536;
int _687893;
_687893 = 2 + _687892;
int _687289;
_687289 = 2 + _687288;
int _685416;
_685416 = 2 + _685415;
int _687047;
_687047 = 2 + _687046;
int _685235;
_685235 = 2 + _685234;
int _686322;
_686322 = 2 + _686321;
int _686171;
_686171 = 2 + _686170;
int _686141;
_686141 = 2 + _686140;
int _686836;
_686836 = 2 + _686835;
int _685628;
_685628 = 2 + _685627;
int _685144;
_685144 = 2 + _685143;
int _687621;
_687621 = 2 + _687620;
int _687409;
_687409 = 2 + _687408;
int _687832;
_687832 = 2 + _687831;
int _687591;
_687591 = 2 + _687590;
int _687802;
_687802 = 2 + _687801;
int _687681;
_687681 = 2 + _687680;
int _685326;
_685326 = 2 + _685325;
int _687379;
_687379 = 2 + _687378;
int _686111;
_686111 = 2 + _686110;
int _685356;
_685356 = 2 + _685355;
int _685779;
_685779 = 2 + _685778;
int _686352;
_686352 = 2 + _686351;
int _686201;
_686201 = 2 + _686200;
int _685446;
_685446 = 2 + _685445;
int _686534;
_686534 = 2 + _686533;
int _685175;
_685175 = 2 + _685174;
int _685748;
_685748 = 2 + _685747;
int _685386;
_685386 = 2 + _685385;
int _686232;
_686232 = 2 + _686231;
int _687711;
_687711 = 2 + _687710;
int _685899;
_685899 = 2 + _685898;
int _686262;
_686262 = 2 + _686261;
int _685023;
_685023 = 2 + _685022;
int _686987;
_686987 = 2 + _686986;
int _685295;
_685295 = 2 + _685294;
int _686050;
_686050 = 2 + _686049;
int _686316;
_686316 = 2 + _686315;
int _685169;
_685169 = 2 + _685168;
int _687585;
_687585 = 2 + _687584;
int _687132;
_687132 = 2 + _687131;
int _687283;
_687283 = 2 + _687282;
int _687675;
_687675 = 2 + _687674;
int _686830;
_686830 = 2 + _686829;
int _685289;
_685289 = 2 + _685288;
int _685048;
_685048 = 2 + _685047;
int _685742;
_685742 = 2 + _685741;
int _685863;
_685863 = 2 + _685862;
int _685350;
_685350 = 2 + _685349;
int _685622;
_685622 = 2 + _685621;
int _685108;
_685108 = 2 + _685107;
int _687856;
_687856 = 2 + _687855;
int _687615;
_687615 = 2 + _687614;
int _686226;
_686226 = 2 + _686225;
int _686135;
_686135 = 2 + _686134;
int _686014;
_686014 = 2 + _686013;
int _685138;
_685138 = 2 + _685137;
int _686528;
_686528 = 2 + _686527;
int _685229;
_685229 = 2 + _685228;
int _685893;
_685893 = 2 + _685892;
int _686044;
_686044 = 2 + _686043;
int _687947;
_687947 = 2 + _687946;
int _685440;
_685440 = 2 + _685439;
int _687041;
_687041 = 2 + _687040;
int _686105;
_686105 = 2 + _686104;
int _687071;
_687071 = 2 + _687070;
int _685016;
_685016 = 2 + _685015;
int _686195;
_686195 = 2 + _686194;
int _686165;
_686165 = 2 + _686164;
int _686075;
_686075 = 2 + _686074;
int _687826;
_687826 = 2 + _687825;
int _686346;
_686346 = 2 + _686345;
int _687917;
_687917 = 2 + _687916;
int _687977;
_687977 = 2 + _687976;
int _686256;
_686256 = 2 + _686255;
int _685803;
_685803 = 2 + _685802;
int _685410;
_685410 = 2 + _685409;
int _685078;
_685078 = 2 + _685077;
int _687796;
_687796 = 2 + _687795;
int _685380;
_685380 = 2 + _685379;
int _687645;
_687645 = 2 + _687644;
int _687373;
_687373 = 2 + _687372;
int _687403;
_687403 = 2 + _687402;
int _685924;
_685924 = 2 + _685923;
int _685320;
_685320 = 2 + _685319;
int _685773;
_685773 = 2 + _685772;
int _686981;
_686981 = 2 + _686980;
int _687705;
_687705 = 2 + _687704;
int _687887;
_687887 = 2 + _687886;
int _685531;
_685531 = 2 + _685530;
float* _685646;
_685646 = _453093_681168 + _685645;
float* _685641;
_685641 = _453093_681168 + _685640;
float* _685636;
_685636 = _453093_681168 + _685635;
float* _682803;
_682803 = _453093_681168 + _682802;
float* _682798;
_682798 = _453093_681168 + _682797;
float* _682793;
_682793 = _453093_681168 + _682792;
float* _682380;
_682380 = _453093_681168 + _682379;
float* _682375;
_682375 = _453093_681168 + _682374;
float* _682370;
_682370 = _453093_681168 + _682369;
float* _684705;
_684705 = _453093_681168 + _684704;
float* _684700;
_684700 = _453093_681168 + _684699;
float* _684695;
_684695 = _453093_681168 + _684694;
float* _684283;
_684283 = _453093_681168 + _684282;
float* _684278;
_684278 = _453093_681168 + _684277;
float* _684273;
_684273 = _453093_681168 + _684272;
float* _685555;
_685555 = _453093_681168 + _685554;
float* _685550;
_685550 = _453093_681168 + _685549;
float* _685545;
_685545 = _453093_681168 + _685544;
float* _684856;
_684856 = _453093_681168 + _684855;
float* _684851;
_684851 = _453093_681168 + _684850;
float* _684846;
_684846 = _453093_681168 + _684845;
int _684984;
_684984 = 2 * _684983;
int _684652;
_684652 = 2 * _684651;
int _684290;
_684290 = 2 * _684289;
int _684713;
_684713 = 2 * _684712;
int _683746;
_683746 = 2 * _683745;
int _684924;
_684924 = 2 * _684923;
int _682115;
_682115 = 2 * _682114;
int _683776;
_683776 = 2 * _683775;
int _683505;
_683505 = 2 * _683504;
int _682055;
_682055 = 2 * _682054;
int _682659;
_682659 = 2 * _682658;
int _684441;
_684441 = 2 * _684440;
int _682508;
_682508 = 2 * _682507;
int _683625;
_683625 = 2 * _683624;
int _684592;
_684592 = 2 * _684591;
int _684622;
_684622 = 2 * _684621;
int _684773;
_684773 = 2 * _684772;
int _684562;
_684562 = 2 * _684561;
int _683142;
_683142 = 2 * _683141;
int _683535;
_683535 = 2 * _683534;
int _683656;
_683656 = 2 * _683655;
int _683323;
_683323 = 2 * _683322;
int _683565;
_683565 = 2 * _683564;
int _683233;
_683233 = 2 * _683232;
int _684954;
_684954 = 2 * _684953;
int _683112;
_683112 = 2 * _683111;
int _683807;
_683807 = 2 * _683806;
int _683203;
_683203 = 2 * _683202;
int _683686;
_683686 = 2 * _683685;
int _682810;
_682810 = 2 * _682809;
int _682478;
_682478 = 2 * _682477;
int _683716;
_683716 = 2 * _683715;
int _684894;
_684894 = 2 * _684893;
int _684350;
_684350 = 2 * _684349;
int _683414;
_683414 = 2 * _683413;
int _682417;
_682417 = 2 * _682416;
int _683837;
_683837 = 2 * _683836;
int _684803;
_684803 = 2 * _684802;
int _682448;
_682448 = 2 * _682447;
int _683595;
_683595 = 2 * _683594;
int _684501;
_684501 = 2 * _684500;
float* _687005;
_687005 = _453093_681168 + _687004;
float* _687000;
_687000 = _453093_681168 + _686999;
float* _686995;
_686995 = _453093_681168 + _686994;
float* _683890;
_683890 = _453093_681168 + _683889;
float* _683885;
_683885 = _453093_681168 + _683884;
float* _683880;
_683880 = _453093_681168 + _683879;
float* _687095;
_687095 = _453093_681168 + _687094;
float* _687090;
_687090 = _453093_681168 + _687089;
float* _687085;
_687085 = _453093_681168 + _687084;
float* _683316;
_683316 = _453093_681168 + _683315;
float* _683311;
_683311 = _453093_681168 + _683310;
float* _683306;
_683306 = _453093_681168 + _683305;
float* _683920;
_683920 = _453093_681168 + _683919;
float* _683915;
_683915 = _453093_681168 + _683914;
float* _683910;
_683910 = _453093_681168 + _683909;
float* _682591;
_682591 = _453093_681168 + _682590;
float* _682586;
_682586 = _453093_681168 + _682585;
float* _682581;
_682581 = _453093_681168 + _682580;
float* _686552;
_686552 = _453093_681168 + _686551;
float* _686547;
_686547 = _453093_681168 + _686546;
float* _686542;
_686542 = _453093_681168 + _686541;
float* _687156;
_687156 = _453093_681168 + _687155;
float* _687151;
_687151 = _453093_681168 + _687150;
float* _687146;
_687146 = _453093_681168 + _687145;
float* _685766;
_685766 = _453093_681168 + _685765;
float* _685761;
_685761 = _453093_681168 + _685760;
float* _685756;
_685756 = _453093_681168 + _685755;
float* _682350;
_682350 = _453093_681168 + _682349;
float* _682345;
_682345 = _453093_681168 + _682344;
float* _682340;
_682340 = _453093_681168 + _682339;
float* _682561;
_682561 = _453093_681168 + _682560;
float* _682556;
_682556 = _453093_681168 + _682555;
float* _682551;
_682551 = _453093_681168 + _682550;
int _687034;
_687034 = 2 * _687033;
int _687029;
_687029 = 2 * _687028;
int _687024;
_687024 = 2 * _687023;
int _687012;
_687012 = 2 * _687011;
int _687018;
_687018 = 2 * _687017;
int _683587;
_683587 = 2 * _683586;
int _683582;
_683582 = 2 * _683581;
int _683577;
_683577 = 2 * _683576;
float* _682569;
_682569 = _453093_681168 + _682568;
float* _683264;
_683264 = _453093_681168 + _683263;
int _687457;
_687457 = 2 * _687456;
int _687452;
_687452 = 2 * _687451;
int _687447;
_687447 = 2 * _687446;
int _687435;
_687435 = 2 * _687434;
int _687441;
_687441 = 2 * _687440;
float* _684865;
_684865 = _453093_681168 + _684864;
int _683979;
_683979 = 4 + _683968;
int _683974;
_683974 = 3 + _683968;
int _683969;
_683969 = 2 + _683968;
int _683957;
_683957 = 2 + _683956;
int _683963;
_683963 = 2 + _683962;
int _684009;
_684009 = 4 + _683998;
int _684004;
_684004 = 3 + _683998;
int _683999;
_683999 = 2 + _683998;
int _683987;
_683987 = 2 + _683986;
int _683993;
_683993 = 2 + _683992;
int _684039;
_684039 = 4 + _684028;
int _684034;
_684034 = 3 + _684028;
int _684029;
_684029 = 2 + _684028;
int _684017;
_684017 = 2 + _684016;
int _684023;
_684023 = 2 + _684022;
int _684099;
_684099 = 4 + _684088;
int _684094;
_684094 = 3 + _684088;
int _684089;
_684089 = 2 + _684088;
int _684077;
_684077 = 2 + _684076;
int _684083;
_684083 = 2 + _684082;
int _684069;
_684069 = 4 + _684058;
int _684064;
_684064 = 3 + _684058;
int _684059;
_684059 = 2 + _684058;
int _684047;
_684047 = 2 + _684046;
int _684053;
_684053 = 2 + _684052;
int _685494;
_685494 = 2 * _685493;
int _685489;
_685489 = 2 * _685488;
int _685484;
_685484 = 2 * _685483;
int _685472;
_685472 = 2 * _685471;
int _685478;
_685478 = 2 * _685477;
int _685311;
_685311 = 5 + _685300;
int _685306;
_685306 = 4 + _685300;
int _685301;
_685301 = 3 + _685300;
int _685251;
_685251 = 5 + _685240;
int _685246;
_685246 = 4 + _685240;
int _685241;
_685241 = 3 + _685240;
int _685191;
_685191 = 5 + _685180;
int _685186;
_685186 = 4 + _685180;
int _685181;
_685181 = 3 + _685180;
int _684341;
_684341 = 4 + _684330;
int _684336;
_684336 = 3 + _684330;
int _684331;
_684331 = 2 + _684330;
int _684319;
_684319 = 2 + _684318;
int _684325;
_684325 = 2 + _684324;
int _684401;
_684401 = 4 + _684390;
int _684396;
_684396 = 3 + _684390;
int _684391;
_684391 = 2 + _684390;
int _684379;
_684379 = 2 + _684378;
int _684385;
_684385 = 2 + _684384;
int _682771;
_682771 = 4 + _682760;
int _682766;
_682766 = 3 + _682760;
int _682761;
_682761 = 2 + _682760;
int _682749;
_682749 = 2 + _682748;
int _682755;
_682755 = 2 + _682754;
int _682891;
_682891 = 4 + _682880;
int _682886;
_682886 = 3 + _682880;
int _682881;
_682881 = 2 + _682880;
int _682869;
_682869 = 2 + _682868;
int _682875;
_682875 = 2 + _682874;
int _685222;
_685222 = 2 * _685221;
int _685217;
_685217 = 2 * _685216;
int _685212;
_685212 = 2 * _685211;
int _685200;
_685200 = 2 * _685199;
int _685206;
_685206 = 2 * _685205;
int _684312;
_684312 = 2 * _684311;
int _684307;
_684307 = 2 * _684306;
int _684302;
_684302 = 2 * _684301;
int _684644;
_684644 = 2 * _684643;
int _684639;
_684639 = 2 * _684638;
int _684634;
_684634 = 2 * _684633;
int _687305;
_687305 = 5 + _687294;
int _687300;
_687300 = 4 + _687294;
int _687295;
_687295 = 3 + _687294;
int _687395;
_687395 = 5 + _687384;
int _687390;
_687390 = 4 + _687384;
int _687385;
_687385 = 3 + _687384;
int _687425;
_687425 = 5 + _687414;
int _687420;
_687420 = 4 + _687414;
int _687415;
_687415 = 3 + _687414;
float* _684744;
_684744 = _453093_681168 + _684743;
float* _684750;
_684750 = _453093_681168 + _684749;
int _686822;
_686822 = 2 * _686821;
int _686817;
_686817 = 2 * _686816;
int _686812;
_686812 = 2 * _686811;
int _686800;
_686800 = 2 * _686799;
int _686806;
_686806 = 2 * _686805;
int _683345;
_683345 = 2 * _683344;
int _683340;
_683340 = 2 * _683339;
int _683335;
_683335 = 2 * _683334;
int _686762;
_686762 = 2 * _686761;
int _686757;
_686757 = 2 * _686756;
int _686752;
_686752 = 2 * _686751;
int _686740;
_686740 = 2 * _686739;
int _686746;
_686746 = 2 * _686745;
int _686460;
_686460 = 2 * _686459;
int _686455;
_686455 = 2 * _686454;
int _686450;
_686450 = 2 * _686449;
int _686438;
_686438 = 2 * _686437;
int _686444;
_686444 = 2 * _686443;
int _684946;
_684946 = 2 * _684945;
int _684941;
_684941 = 2 * _684940;
int _684936;
_684936 = 2 * _684935;
float* _682545;
_682545 = _453093_681168 + _682544;
float* _683330;
_683330 = _453093_681168 + _683329;
float* _684629;
_684629 = _453093_681168 + _684628;
float* _683572;
_683572 = _453093_681168 + _683571;
float* _683934;
_683934 = _453093_681168 + _683933;
float* _684931;
_684931 = _453093_681168 + _684930;
float* _683874;
_683874 = _453093_681168 + _683873;
float* _682847;
_682847 = _453093_681168 + _682846;
float* _684297;
_684297 = _453093_681168 + _684296;
float* _682364;
_682364 = _453093_681168 + _682363;
float* _683300;
_683300 = _453093_681168 + _683299;
float* _682334;
_682334 = _453093_681168 + _682333;
float* _684840;
_684840 = _453093_681168 + _684839;
float* _684267;
_684267 = _453093_681168 + _684266;
float* _683904;
_683904 = _453093_681168 + _683903;
int _682408;
_682408 = 4 + _682397;
int _682403;
_682403 = 3 + _682397;
int _682398;
_682398 = 2 + _682397;
int _682386;
_682386 = 2 + _682385;
int _682392;
_682392 = 2 + _682391;
int _682318;
_682318 = 4 + _682307;
int _682313;
_682313 = 3 + _682307;
int _682308;
_682308 = 2 + _682307;
int _682296;
_682296 = 2 + _682295;
int _682302;
_682302 = 2 + _682301;
int _684372;
_684372 = 2 * _684371;
int _684367;
_684367 = 2 * _684366;
int _684362;
_684362 = 2 * _684361;
int _684356;
_684356 = 2 * _684355;
float* _683294;
_683294 = _453093_681168 + _683293;
int _687547;
_687547 = 2 * _687546;
int _687542;
_687542 = 2 * _687541;
int _687537;
_687537 = 2 * _687536;
int _687525;
_687525 = 2 * _687524;
int _687531;
_687531 = 2 * _687530;
int _686520;
_686520 = 2 * _686519;
int _686515;
_686515 = 2 * _686514;
int _686510;
_686510 = 2 * _686509;
int _686498;
_686498 = 2 * _686497;
int _686504;
_686504 = 2 * _686503;
int _685342;
_685342 = 5 + _685331;
int _685337;
_685337 = 4 + _685331;
int _685332;
_685332 = 3 + _685331;
int _685402;
_685402 = 5 + _685391;
int _685397;
_685397 = 4 + _685391;
int _685392;
_685392 = 3 + _685391;
int _685432;
_685432 = 5 + _685421;
int _685427;
_685427 = 4 + _685421;
int _685422;
_685422 = 3 + _685421;
int _685372;
_685372 = 5 + _685361;
int _685367;
_685367 = 4 + _685361;
int _685362;
_685362 = 3 + _685361;
int _685462;
_685462 = 5 + _685451;
int _685457;
_685457 = 4 + _685451;
int _685452;
_685452 = 3 + _685451;
float* _684834;
_684834 = _453093_681168 + _684833;
int _682227;
_682227 = 4 + _682216;
int _682222;
_682222 = 3 + _682216;
int _682217;
_682217 = 2 + _682216;
int _682205;
_682205 = 2 + _682204;
int _682211;
_682211 = 2 + _682210;
int _682287;
_682287 = 4 + _682276;
int _682282;
_682282 = 3 + _682276;
int _682277;
_682277 = 2 + _682276;
int _682265;
_682265 = 2 + _682264;
int _682271;
_682271 = 2 + _682270;
int _682257;
_682257 = 4 + _682246;
int _682252;
_682252 = 3 + _682246;
int _682247;
_682247 = 2 + _682246;
int _682235;
_682235 = 2 + _682234;
int _682241;
_682241 = 2 + _682240;
int _682197;
_682197 = 4 + _682186;
int _682192;
_682192 = 3 + _682186;
int _682187;
_682187 = 2 + _682186;
int _682175;
_682175 = 2 + _682174;
int _682181;
_682181 = 2 + _682180;
int _682167;
_682167 = 4 + _682156;
int _682162;
_682162 = 3 + _682156;
int _682157;
_682157 = 2 + _682156;
int _682145;
_682145 = 2 + _682144;
int _682151;
_682151 = 2 + _682150;
int _683012;
_683012 = 4 + _683001;
int _683007;
_683007 = 3 + _683001;
int _683002;
_683002 = 2 + _683001;
int _682990;
_682990 = 2 + _682989;
int _682996;
_682996 = 2 + _682995;
int _682952;
_682952 = 4 + _682941;
int _682947;
_682947 = 3 + _682941;
int _682942;
_682942 = 2 + _682941;
int _682930;
_682930 = 2 + _682929;
int _682936;
_682936 = 2 + _682935;
int _682922;
_682922 = 4 + _682911;
int _682917;
_682917 = 3 + _682911;
int _682912;
_682912 = 2 + _682911;
int _682900;
_682900 = 2 + _682899;
int _682906;
_682906 = 2 + _682905;
int _682982;
_682982 = 4 + _682971;
int _682977;
_682977 = 3 + _682971;
int _682972;
_682972 = 2 + _682971;
int _682960;
_682960 = 2 + _682959;
int _682966;
_682966 = 2 + _682965;
int _683042;
_683042 = 4 + _683031;
int _683037;
_683037 = 3 + _683031;
int _683032;
_683032 = 2 + _683031;
int _683020;
_683020 = 2 + _683019;
int _683026;
_683026 = 2 + _683025;
float* _683928;
_683928 = _453093_681168 + _683927;
float* _684683;
_684683 = _453093_681168 + _684682;
int _684735;
_684735 = 2 * _684734;
int _684730;
_684730 = 2 * _684729;
int _684725;
_684725 = 2 * _684724;
int _684719;
_684719 = 2 * _684718;
int _682500;
_682500 = 2 * _682499;
int _682495;
_682495 = 2 * _682494;
int _682490;
_682490 = 2 * _682489;
int _682484;
_682484 = 2 * _682483;
int _686338;
_686338 = 5 + _686327;
int _686333;
_686333 = 4 + _686327;
int _686328;
_686328 = 3 + _686327;
int _686248;
_686248 = 5 + _686237;
int _686243;
_686243 = 4 + _686237;
int _686238;
_686238 = 3 + _686237;
int _686368;
_686368 = 5 + _686357;
int _686363;
_686363 = 4 + _686357;
int _686358;
_686358 = 3 + _686357;
int _686278;
_686278 = 5 + _686267;
int _686273;
_686273 = 4 + _686267;
int _686268;
_686268 = 3 + _686267;
float* _682358;
_682358 = _453093_681168 + _682357;
float* _683898;
_683898 = _453093_681168 + _683897;
int _683527;
_683527 = 2 * _683526;
int _683522;
_683522 = 2 * _683521;
int _683517;
_683517 = 2 * _683516;
int _683511;
_683511 = 2 * _683510;
int _682740;
_682740 = 4 + _682729;
int _682735;
_682735 = 3 + _682729;
int _682730;
_682730 = 2 + _682729;
int _682718;
_682718 = 2 + _682717;
int _682724;
_682724 = 2 + _682723;
int _682620;
_682620 = 4 + _682609;
int _682615;
_682615 = 3 + _682609;
int _682610;
_682610 = 2 + _682609;
int _682598;
_682598 = 2 + _682597;
int _682604;
_682604 = 2 + _682603;
int _682710;
_682710 = 4 + _682699;
int _682705;
_682705 = 3 + _682699;
int _682700;
_682700 = 2 + _682699;
int _682688;
_682688 = 2 + _682687;
int _682694;
_682694 = 2 + _682693;
int _682650;
_682650 = 4 + _682639;
int _682645;
_682645 = 3 + _682639;
int _682640;
_682640 = 2 + _682639;
int _682628;
_682628 = 2 + _682627;
int _682634;
_682634 = 2 + _682633;
int _685282;
_685282 = 2 * _685281;
int _685277;
_685277 = 2 * _685276;
int _685272;
_685272 = 2 * _685271;
int _685260;
_685260 = 2 * _685259;
int _685266;
_685266 = 2 * _685265;
int _687848;
_687848 = 5 + _687837;
int _687843;
_687843 = 4 + _687837;
int _687838;
_687838 = 3 + _687837;
int _687878;
_687878 = 5 + _687867;
int _687873;
_687873 = 4 + _687867;
int _687868;
_687868 = 3 + _687867;
int _687818;
_687818 = 5 + _687807;
int _687813;
_687813 = 4 + _687807;
int _687808;
_687808 = 3 + _687807;
int _687517;
_687517 = 2 * _687516;
int _687512;
_687512 = 2 * _687511;
int _687507;
_687507 = 2 * _687506;
int _687495;
_687495 = 2 * _687494;
int _687501;
_687501 = 2 * _687500;
int _686641;
_686641 = 2 * _686640;
int _686636;
_686636 = 2 * _686635;
int _686631;
_686631 = 2 * _686630;
int _686619;
_686619 = 2 * _686618;
int _686625;
_686625 = 2 * _686624;
float* _682781;
_682781 = _453093_681168 + _682780;
int _684976;
_684976 = 2 * _684975;
int _684971;
_684971 = 2 * _684970;
int _684966;
_684966 = 2 * _684965;
int _684960;
_684960 = 2 * _684959;
int _682106;
_682106 = 4 + _682095;
int _682101;
_682101 = 3 + _682095;
int _682096;
_682096 = 2 + _682095;
int _682084;
_682084 = 2 + _682083;
int _682090;
_682090 = 2 + _682089;
int _682046;
_682046 = 4 + _682035;
int _682041;
_682041 = 3 + _682035;
int _682036;
_682036 = 2 + _682035;
int _682024;
_682024 = 2 + _682023;
int _682030;
_682030 = 2 + _682029;
int _682016;
_682016 = 4 + _682004;
int _682010;
_682010 = 3 + _682004;
int _682005;
_682005 = 2 + _682004;
int _681992;
_681992 = 2 + _681991;
int _681999;
_681999 = 2 + _681998;
int _686036;
_686036 = 5 + _686025;
int _686031;
_686031 = 4 + _686025;
int _686026;
_686026 = 3 + _686025;
int _685946;
_685946 = 5 + _685935;
int _685941;
_685941 = 4 + _685935;
int _685936;
_685936 = 3 + _685935;
int _686066;
_686066 = 5 + _686055;
int _686061;
_686061 = 4 + _686055;
int _686056;
_686056 = 3 + _686055;
int _686400;
_686400 = 2 * _686399;
int _686395;
_686395 = 2 * _686394;
int _686390;
_686390 = 2 * _686389;
int _686378;
_686378 = 2 * _686377;
int _686384;
_686384 = 2 * _686383;
float* _682841;
_682841 = _453093_681168 + _682840;
int _687969;
_687969 = 5 + _687958;
int _687964;
_687964 = 4 + _687958;
int _687959;
_687959 = 3 + _687958;
int _687999;
_687999 = 5 + _687988;
int _687994;
_687994 = 4 + _687988;
int _687989;
_687989 = 3 + _687988;
int _687939;
_687939 = 5 + _687928;
int _687934;
_687934 = 4 + _687928;
int _687929;
_687929 = 3 + _687928;
int _687909;
_687909 = 5 + _687898;
int _687904;
_687904 = 4 + _687898;
int _687899;
_687899 = 3 + _687898;
float* _684261;
_684261 = _453093_681168 + _684260;
int _686430;
_686430 = 2 * _686429;
int _686425;
_686425 = 2 * _686424;
int _686420;
_686420 = 2 * _686419;
int _686408;
_686408 = 2 * _686407;
int _686414;
_686414 = 2 * _686413;
int _683859;
_683859 = 2 * _683858;
int _683854;
_683854 = 2 * _683853;
int _683849;
_683849 = 2 * _683848;
int _683843;
_683843 = 2 * _683842;
int _683255;
_683255 = 2 * _683254;
int _683250;
_683250 = 2 * _683249;
int _683245;
_683245 = 2 * _683244;
int _683239;
_683239 = 2 * _683238;
int _684432;
_684432 = 4 + _684421;
int _684427;
_684427 = 3 + _684421;
int _684422;
_684422 = 2 + _684421;
int _684410;
_684410 = 2 + _684409;
int _684416;
_684416 = 2 + _684415;
int _684492;
_684492 = 4 + _684481;
int _684487;
_684487 = 3 + _684481;
int _684482;
_684482 = 2 + _684481;
int _684470;
_684470 = 2 + _684469;
int _684476;
_684476 = 2 + _684475;
int _684552;
_684552 = 4 + _684541;
int _684547;
_684547 = 3 + _684541;
int _684542;
_684542 = 2 + _684541;
int _684530;
_684530 = 2 + _684529;
int _684536;
_684536 = 2 + _684535;
int _683103;
_683103 = 4 + _683092;
int _683098;
_683098 = 3 + _683092;
int _683093;
_683093 = 2 + _683092;
int _683081;
_683081 = 2 + _683080;
int _683087;
_683087 = 2 + _683086;
int _683073;
_683073 = 4 + _683062;
int _683068;
_683068 = 3 + _683062;
int _683063;
_683063 = 2 + _683062;
int _683051;
_683051 = 2 + _683050;
int _683057;
_683057 = 2 + _683056;
int _683193;
_683193 = 4 + _683182;
int _683188;
_683188 = 3 + _683182;
int _683183;
_683183 = 2 + _683182;
int _683171;
_683171 = 2 + _683170;
int _683177;
_683177 = 2 + _683176;
int _683557;
_683557 = 2 * _683556;
int _683552;
_683552 = 2 * _683551;
int _683547;
_683547 = 2 * _683546;
int _683541;
_683541 = 2 * _683540;
int _685614;
_685614 = 2 * _685613;
int _685609;
_685609 = 2 * _685608;
int _685604;
_685604 = 2 * _685603;
int _685592;
_685592 = 2 * _685591;
int _685598;
_685598 = 2 * _685597;
int _685584;
_685584 = 2 * _685583;
int _685579;
_685579 = 2 * _685578;
int _685574;
_685574 = 2 * _685573;
int _685562;
_685562 = 2 * _685561;
int _685568;
_685568 = 2 * _685567;
int _686007;
_686007 = 2 * _686006;
int _686002;
_686002 = 2 * _686001;
int _685997;
_685997 = 2 * _685996;
int _685985;
_685985 = 2 * _685984;
int _685991;
_685991 = 2 * _685990;
int _683134;
_683134 = 2 * _683133;
int _683129;
_683129 = 2 * _683128;
int _683124;
_683124 = 2 * _683123;
int _683118;
_683118 = 2 * _683117;
int _684674;
_684674 = 2 * _684673;
int _684669;
_684669 = 2 * _684668;
int _684664;
_684664 = 2 * _684663;
int _684658;
_684658 = 2 * _684657;
int _687759;
_687759 = 2 * _687758;
int _687754;
_687754 = 2 * _687753;
int _687749;
_687749 = 2 * _687748;
int _687737;
_687737 = 2 * _687736;
int _687743;
_687743 = 2 * _687742;
int _683708;
_683708 = 2 * _683707;
int _683703;
_683703 = 2 * _683702;
int _683698;
_683698 = 2 * _683697;
int _683692;
_683692 = 2 * _683691;
int _682137;
_682137 = 2 * _682136;
int _682132;
_682132 = 2 * _682131;
int _682127;
_682127 = 2 * _682126;
int _682121;
_682121 = 2 * _682120;
int _682077;
_682077 = 2 * _682076;
int _682072;
_682072 = 2 * _682071;
int _682067;
_682067 = 2 * _682066;
int _682061;
_682061 = 2 * _682060;
int _682681;
_682681 = 2 * _682680;
int _682676;
_682676 = 2 * _682675;
int _682671;
_682671 = 2 * _682670;
int _682665;
_682665 = 2 * _682664;
int _683678;
_683678 = 2 * _683677;
int _683673;
_683673 = 2 * _683672;
int _683668;
_683668 = 2 * _683667;
int _683662;
_683662 = 2 * _683661;
int _687336;
_687336 = 2 * _687335;
int _687331;
_687331 = 2 * _687330;
int _687326;
_687326 = 2 * _687325;
int _687314;
_687314 = 2 * _687313;
int _687320;
_687320 = 2 * _687319;
int _686309;
_686309 = 2 * _686308;
int _686304;
_686304 = 2 * _686303;
int _686299;
_686299 = 2 * _686298;
int _686287;
_686287 = 2 * _686286;
int _686293;
_686293 = 2 * _686292;
int _682439;
_682439 = 2 * _682438;
int _682434;
_682434 = 2 * _682433;
int _682429;
_682429 = 2 * _682428;
int _682423;
_682423 = 2 * _682422;
int _682832;
_682832 = 2 * _682831;
int _682827;
_682827 = 2 * _682826;
int _682822;
_682822 = 2 * _682821;
int _682816;
_682816 = 2 * _682815;
int _687667;
_687667 = 5 + _687656;
int _687662;
_687662 = 4 + _687656;
int _687657;
_687657 = 3 + _687656;
int _687637;
_687637 = 5 + _687626;
int _687632;
_687632 = 4 + _687626;
int _687627;
_687627 = 3 + _687626;
int _687697;
_687697 = 5 + _687686;
int _687692;
_687692 = 4 + _687686;
int _687687;
_687687 = 3 + _687686;
int _687607;
_687607 = 5 + _687596;
int _687602;
_687602 = 4 + _687596;
int _687597;
_687597 = 3 + _687596;
int _687727;
_687727 = 5 + _687716;
int _687722;
_687722 = 4 + _687716;
int _687717;
_687717 = 3 + _687716;
int _685524;
_685524 = 2 * _685523;
int _685519;
_685519 = 2 * _685518;
int _685514;
_685514 = 2 * _685513;
int _685502;
_685502 = 2 * _685501;
int _685508;
_685508 = 2 * _685507;
int _687366;
_687366 = 2 * _687365;
int _687361;
_687361 = 2 * _687360;
int _687356;
_687356 = 2 * _687355;
int _687344;
_687344 = 2 * _687343;
int _687350;
_687350 = 2 * _687349;
int _683225;
_683225 = 2 * _683224;
int _683220;
_683220 = 2 * _683219;
int _683215;
_683215 = 2 * _683214;
int _683209;
_683209 = 2 * _683208;
int _684463;
_684463 = 2 * _684462;
int _684458;
_684458 = 2 * _684457;
int _684453;
_684453 = 2 * _684452;
int _684447;
_684447 = 2 * _684446;
int _687124;
_687124 = 2 * _687123;
int _687119;
_687119 = 2 * _687118;
int _687114;
_687114 = 2 * _687113;
int _687102;
_687102 = 2 * _687101;
int _687108;
_687108 = 2 * _687107;
int _686883;
_686883 = 2 * _686882;
int _686878;
_686878 = 2 * _686877;
int _686873;
_686873 = 2 * _686872;
int _686861;
_686861 = 2 * _686860;
int _686867;
_686867 = 2 * _686866;
int _687185;
_687185 = 2 * _687184;
int _687180;
_687180 = 2 * _687179;
int _687175;
_687175 = 2 * _687174;
int _687163;
_687163 = 2 * _687162;
int _687169;
_687169 = 2 * _687168;
int _683164;
_683164 = 2 * _683163;
int _683159;
_683159 = 2 * _683158;
int _683154;
_683154 = 2 * _683153;
int _683148;
_683148 = 2 * _683147;
int _685915;
_685915 = 5 + _685904;
int _685910;
_685910 = 4 + _685904;
int _685905;
_685905 = 3 + _685904;
int _685795;
_685795 = 5 + _685784;
int _685790;
_685790 = 4 + _685784;
int _685785;
_685785 = 3 + _685784;
int _685885;
_685885 = 5 + _685874;
int _685880;
_685880 = 4 + _685874;
int _685875;
_685875 = 3 + _685874;
int _685825;
_685825 = 5 + _685814;
int _685820;
_685820 = 4 + _685814;
int _685815;
_685815 = 3 + _685814;
int _684825;
_684825 = 2 * _684824;
int _684820;
_684820 = 2 * _684819;
int _684815;
_684815 = 2 * _684814;
int _684809;
_684809 = 2 * _684808;
int _683647;
_683647 = 2 * _683646;
int _683642;
_683642 = 2 * _683641;
int _683637;
_683637 = 2 * _683636;
int _683631;
_683631 = 2 * _683630;
int _682530;
_682530 = 2 * _682529;
int _682525;
_682525 = 2 * _682524;
int _682520;
_682520 = 2 * _682519;
int _682514;
_682514 = 2 * _682513;
int _687487;
_687487 = 2 * _687486;
int _687482;
_687482 = 2 * _687481;
int _687477;
_687477 = 2 * _687476;
int _687465;
_687465 = 2 * _687464;
int _687471;
_687471 = 2 * _687470;
int _685675;
_685675 = 2 * _685674;
int _685670;
_685670 = 2 * _685669;
int _685665;
_685665 = 2 * _685664;
int _685653;
_685653 = 2 * _685652;
int _685659;
_685659 = 2 * _685658;
int _685100;
_685100 = 5 + _685089;
int _685095;
_685095 = 4 + _685089;
int _685090;
_685090 = 3 + _685089;
int _685160;
_685160 = 5 + _685149;
int _685155;
_685155 = 4 + _685149;
int _685150;
_685150 = 3 + _685149;
int _685130;
_685130 = 5 + _685119;
int _685125;
_685125 = 4 + _685119;
int _685120;
_685120 = 3 + _685119;
int _685040;
_685040 = 5 + _685028;
int _685034;
_685034 = 4 + _685028;
int _685029;
_685029 = 3 + _685028;
int _685070;
_685070 = 5 + _685059;
int _685065;
_685065 = 4 + _685059;
int _685060;
_685060 = 3 + _685059;
int _684523;
_684523 = 2 * _684522;
int _684518;
_684518 = 2 * _684517;
int _684513;
_684513 = 2 * _684512;
int _684507;
_684507 = 2 * _684506;
int _683405;
_683405 = 4 + _683394;
int _683400;
_683400 = 3 + _683394;
int _683395;
_683395 = 2 + _683394;
int _683383;
_683383 = 2 + _683382;
int _683389;
_683389 = 2 + _683388;
int _683495;
_683495 = 4 + _683484;
int _683490;
_683490 = 3 + _683484;
int _683485;
_683485 = 2 + _683484;
int _683473;
_683473 = 2 + _683472;
int _683479;
_683479 = 2 + _683478;
int _683465;
_683465 = 4 + _683454;
int _683460;
_683460 = 3 + _683454;
int _683455;
_683455 = 2 + _683454;
int _683443;
_683443 = 2 + _683442;
int _683449;
_683449 = 2 + _683448;
int _683375;
_683375 = 4 + _683364;
int _683370;
_683370 = 3 + _683364;
int _683365;
_683365 = 2 + _683364;
int _683353;
_683353 = 2 + _683352;
int _683359;
_683359 = 2 + _683358;
int _685977;
_685977 = 2 * _685976;
int _685972;
_685972 = 2 * _685971;
int _685967;
_685967 = 2 * _685966;
int _685955;
_685955 = 2 * _685954;
int _685961;
_685961 = 2 * _685960;
int _685856;
_685856 = 2 * _685855;
int _685851;
_685851 = 2 * _685850;
int _685846;
_685846 = 2 * _685845;
int _685834;
_685834 = 2 * _685833;
int _685840;
_685840 = 2 * _685839;
int _683617;
_683617 = 2 * _683616;
int _683612;
_683612 = 2 * _683611;
int _683607;
_683607 = 2 * _683606;
int _683601;
_683601 = 2 * _683600;
int _683798;
_683798 = 2 * _683797;
int _683793;
_683793 = 2 * _683792;
int _683788;
_683788 = 2 * _683787;
int _683782;
_683782 = 2 * _683781;
int _686187;
_686187 = 5 + _686176;
int _686182;
_686182 = 4 + _686176;
int _686177;
_686177 = 3 + _686176;
int _686127;
_686127 = 5 + _686116;
int _686122;
_686122 = 4 + _686116;
int _686117;
_686117 = 3 + _686116;
int _686097;
_686097 = 5 + _686086;
int _686092;
_686092 = 4 + _686086;
int _686087;
_686087 = 3 + _686086;
int _686217;
_686217 = 5 + _686206;
int _686212;
_686212 = 4 + _686206;
int _686207;
_686207 = 3 + _686206;
int _686157;
_686157 = 5 + _686146;
int _686152;
_686152 = 4 + _686146;
int _686147;
_686147 = 3 + _686146;
int _683436;
_683436 = 2 * _683435;
int _683431;
_683431 = 2 * _683430;
int _683426;
_683426 = 2 * _683425;
int _683420;
_683420 = 2 * _683419;
int _688030;
_688030 = 2 * _688029;
int _688025;
_688025 = 2 * _688024;
int _688020;
_688020 = 2 * _688019;
int _688014;
_688014 = 2 * _688013;
int _688008;
_688008 = 2 * _688007;
int _687789;
_687789 = 2 * _687788;
int _687784;
_687784 = 2 * _687783;
int _687779;
_687779 = 2 * _687778;
int _687767;
_687767 = 2 * _687766;
int _687773;
_687773 = 2 * _687772;
int _686732;
_686732 = 2 * _686731;
int _686727;
_686727 = 2 * _686726;
int _686722;
_686722 = 2 * _686721;
int _686710;
_686710 = 2 * _686709;
int _686716;
_686716 = 2 * _686715;
int _684220;
_684220 = 4 + _684209;
int _684215;
_684215 = 3 + _684209;
int _684210;
_684210 = 2 + _684209;
int _684198;
_684198 = 2 + _684197;
int _684204;
_684204 = 2 + _684203;
int _684250;
_684250 = 4 + _684239;
int _684245;
_684245 = 3 + _684239;
int _684240;
_684240 = 2 + _684239;
int _684228;
_684228 = 2 + _684227;
int _684234;
_684234 = 2 + _684233;
int _684130;
_684130 = 4 + _684119;
int _684125;
_684125 = 3 + _684119;
int _684120;
_684120 = 2 + _684119;
int _684108;
_684108 = 2 + _684107;
int _684114;
_684114 = 2 + _684113;
int _684190;
_684190 = 4 + _684179;
int _684185;
_684185 = 3 + _684179;
int _684180;
_684180 = 2 + _684179;
int _684168;
_684168 = 2 + _684167;
int _684174;
_684174 = 2 + _684173;
int _684160;
_684160 = 4 + _684149;
int _684155;
_684155 = 3 + _684149;
int _684150;
_684150 = 2 + _684149;
int _684138;
_684138 = 2 + _684137;
int _684144;
_684144 = 2 + _684143;
float* _683868;
_683868 = _453093_681168 + _683867;
float* _682328;
_682328 = _453093_681168 + _682327;
int _683768;
_683768 = 2 * _683767;
int _683763;
_683763 = 2 * _683762;
int _683758;
_683758 = 2 * _683757;
int _683752;
_683752 = 2 * _683751;
int _684795;
_684795 = 2 * _684794;
int _684790;
_684790 = 2 * _684789;
int _684785;
_684785 = 2 * _684784;
int _684779;
_684779 = 2 * _684778;
int _682470;
_682470 = 2 * _682469;
int _682465;
_682465 = 2 * _682464;
int _682460;
_682460 = 2 * _682459;
int _682454;
_682454 = 2 * _682453;
int _686913;
_686913 = 2 * _686912;
int _686908;
_686908 = 2 * _686907;
int _686903;
_686903 = 2 * _686902;
int _686891;
_686891 = 2 * _686890;
int _686897;
_686897 = 2 * _686896;
int _686973;
_686973 = 2 * _686972;
int _686968;
_686968 = 2 * _686967;
int _686963;
_686963 = 2 * _686962;
int _686951;
_686951 = 2 * _686950;
int _686957;
_686957 = 2 * _686956;
int _686943;
_686943 = 2 * _686942;
int _686938;
_686938 = 2 * _686937;
int _686933;
_686933 = 2 * _686932;
int _686921;
_686921 = 2 * _686920;
int _686927;
_686927 = 2 * _686926;
int _686490;
_686490 = 2 * _686489;
int _686485;
_686485 = 2 * _686484;
int _686480;
_686480 = 2 * _686479;
int _686468;
_686468 = 2 * _686467;
int _686474;
_686474 = 2 * _686473;
int _683829;
_683829 = 2 * _683828;
int _683824;
_683824 = 2 * _683823;
int _683819;
_683819 = 2 * _683818;
int _683813;
_683813 = 2 * _683812;
int _687245;
_687245 = 2 * _687244;
int _687240;
_687240 = 2 * _687239;
int _687235;
_687235 = 2 * _687234;
int _687223;
_687223 = 2 * _687222;
int _687229;
_687229 = 2 * _687228;
int _687275;
_687275 = 2 * _687274;
int _687270;
_687270 = 2 * _687269;
int _687265;
_687265 = 2 * _687264;
int _687253;
_687253 = 2 * _687252;
int _687259;
_687259 = 2 * _687258;
int _687215;
_687215 = 2 * _687214;
int _687210;
_687210 = 2 * _687209;
int _687205;
_687205 = 2 * _687204;
int _687193;
_687193 = 2 * _687192;
int _687199;
_687199 = 2 * _687198;
int _684584;
_684584 = 2 * _684583;
int _684579;
_684579 = 2 * _684578;
int _684574;
_684574 = 2 * _684573;
int _684568;
_684568 = 2 * _684567;
int _685006;
_685006 = 2 * _685005;
int _685001;
_685001 = 2 * _685000;
int _684996;
_684996 = 2 * _684995;
int _684990;
_684990 = 2 * _684989;
int _684916;
_684916 = 2 * _684915;
int _684911;
_684911 = 2 * _684910;
int _684906;
_684906 = 2 * _684905;
int _684900;
_684900 = 2 * _684899;
float* _682539;
_682539 = _453093_681168 + _682538;
int _687577;
_687577 = 2 * _687576;
int _687572;
_687572 = 2 * _687571;
int _687567;
_687567 = 2 * _687566;
int _687555;
_687555 = 2 * _687554;
int _687561;
_687561 = 2 * _687560;
int _685705;
_685705 = 2 * _685704;
int _685700;
_685700 = 2 * _685699;
int _685695;
_685695 = 2 * _685694;
int _685683;
_685683 = 2 * _685682;
int _685689;
_685689 = 2 * _685688;
int _685735;
_685735 = 2 * _685734;
int _685730;
_685730 = 2 * _685729;
int _685725;
_685725 = 2 * _685724;
int _685713;
_685713 = 2 * _685712;
int _685719;
_685719 = 2 * _685718;
int _686792;
_686792 = 2 * _686791;
int _686787;
_686787 = 2 * _686786;
int _686782;
_686782 = 2 * _686781;
int _686770;
_686770 = 2 * _686769;
int _686776;
_686776 = 2 * _686775;
int _686702;
_686702 = 2 * _686701;
int _686697;
_686697 = 2 * _686696;
int _686692;
_686692 = 2 * _686691;
int _686680;
_686680 = 2 * _686679;
int _686686;
_686686 = 2 * _686685;
int _686671;
_686671 = 2 * _686670;
int _686666;
_686666 = 2 * _686665;
int _686661;
_686661 = 2 * _686660;
int _686649;
_686649 = 2 * _686648;
int _686655;
_686655 = 2 * _686654;
int _686611;
_686611 = 2 * _686610;
int _686606;
_686606 = 2 * _686605;
int _686601;
_686601 = 2 * _686600;
int _686589;
_686589 = 2 * _686588;
int _686595;
_686595 = 2 * _686594;
int _686581;
_686581 = 2 * _686580;
int _686576;
_686576 = 2 * _686575;
int _686571;
_686571 = 2 * _686570;
int _686559;
_686559 = 2 * _686558;
int _686565;
_686565 = 2 * _686564;
int _686021;
_686021 = 2 * _686020;
int _685870;
_685870 = 2 * _685869;
int _685085;
_685085 = 2 * _685084;
int _687652;
_687652 = 2 * _687651;
int _685931;
_685931 = 2 * _685930;
int _687984;
_687984 = 2 * _687983;
int _686082;
_686082 = 2 * _686081;
int _685810;
_685810 = 2 * _685809;
int _687078;
_687078 = 2 * _687077;
int _687863;
_687863 = 2 * _687862;
int _687924;
_687924 = 2 * _687923;
int _685055;
_685055 = 2 * _685054;
int _687139;
_687139 = 2 * _687138;
int _687954;
_687954 = 2 * _687953;
int _685115;
_685115 = 2 * _685114;
int _685538;
_685538 = 2 * _685537;
int _687894;
_687894 = 2 * _687893;
int _687290;
_687290 = 2 * _687289;
int _685417;
_685417 = 2 * _685416;
int _687048;
_687048 = 2 * _687047;
int _685236;
_685236 = 2 * _685235;
int _686323;
_686323 = 2 * _686322;
int _686172;
_686172 = 2 * _686171;
int _686142;
_686142 = 2 * _686141;
int _686837;
_686837 = 2 * _686836;
int _685629;
_685629 = 2 * _685628;
int _685145;
_685145 = 2 * _685144;
int _687622;
_687622 = 2 * _687621;
int _687410;
_687410 = 2 * _687409;
int _687833;
_687833 = 2 * _687832;
int _687592;
_687592 = 2 * _687591;
int _687803;
_687803 = 2 * _687802;
int _687682;
_687682 = 2 * _687681;
int _685327;
_685327 = 2 * _685326;
int _687380;
_687380 = 2 * _687379;
int _686112;
_686112 = 2 * _686111;
int _685357;
_685357 = 2 * _685356;
int _685780;
_685780 = 2 * _685779;
int _686353;
_686353 = 2 * _686352;
int _686202;
_686202 = 2 * _686201;
int _685447;
_685447 = 2 * _685446;
int _686535;
_686535 = 2 * _686534;
int _685176;
_685176 = 2 * _685175;
int _685749;
_685749 = 2 * _685748;
int _685387;
_685387 = 2 * _685386;
int _686233;
_686233 = 2 * _686232;
int _687712;
_687712 = 2 * _687711;
int _685900;
_685900 = 2 * _685899;
int _686263;
_686263 = 2 * _686262;
int _685024;
_685024 = 2 * _685023;
int _686988;
_686988 = 2 * _686987;
int _685296;
_685296 = 2 * _685295;
int _686051;
_686051 = 2 * _686050;
int _686317;
_686317 = 2 * _686316;
int _685170;
_685170 = 2 * _685169;
int _687586;
_687586 = 2 * _687585;
int _687133;
_687133 = 2 * _687132;
int _687284;
_687284 = 2 * _687283;
int _687676;
_687676 = 2 * _687675;
int _686831;
_686831 = 2 * _686830;
int _685290;
_685290 = 2 * _685289;
int _685049;
_685049 = 2 * _685048;
int _685743;
_685743 = 2 * _685742;
int _685864;
_685864 = 2 * _685863;
int _685351;
_685351 = 2 * _685350;
int _685623;
_685623 = 2 * _685622;
int _685109;
_685109 = 2 * _685108;
int _687857;
_687857 = 2 * _687856;
int _687616;
_687616 = 2 * _687615;
int _686227;
_686227 = 2 * _686226;
int _686136;
_686136 = 2 * _686135;
int _686015;
_686015 = 2 * _686014;
int _685139;
_685139 = 2 * _685138;
int _686529;
_686529 = 2 * _686528;
int _685230;
_685230 = 2 * _685229;
int _685894;
_685894 = 2 * _685893;
int _686045;
_686045 = 2 * _686044;
int _687948;
_687948 = 2 * _687947;
int _685441;
_685441 = 2 * _685440;
int _687042;
_687042 = 2 * _687041;
int _686106;
_686106 = 2 * _686105;
int _687072;
_687072 = 2 * _687071;
int _685017;
_685017 = 2 * _685016;
int _686196;
_686196 = 2 * _686195;
int _686166;
_686166 = 2 * _686165;
int _686076;
_686076 = 2 * _686075;
int _687827;
_687827 = 2 * _687826;
int _686347;
_686347 = 2 * _686346;
int _687918;
_687918 = 2 * _687917;
int _687978;
_687978 = 2 * _687977;
int _686257;
_686257 = 2 * _686256;
int _685804;
_685804 = 2 * _685803;
int _685411;
_685411 = 2 * _685410;
int _685079;
_685079 = 2 * _685078;
int _687797;
_687797 = 2 * _687796;
int _685381;
_685381 = 2 * _685380;
int _687646;
_687646 = 2 * _687645;
int _687374;
_687374 = 2 * _687373;
int _687404;
_687404 = 2 * _687403;
int _685925;
_685925 = 2 * _685924;
int _685321;
_685321 = 2 * _685320;
int _685774;
_685774 = 2 * _685773;
int _686982;
_686982 = 2 * _686981;
int _687706;
_687706 = 2 * _687705;
int _687888;
_687888 = 2 * _687887;
int _685532;
_685532 = 2 * _685531;
float* _684985;
_684985 = _453093_681168 + _684984;
float* _684653;
_684653 = _453093_681168 + _684652;
float* _684291;
_684291 = _453093_681168 + _684290;
float* _684714;
_684714 = _453093_681168 + _684713;
float* _683747;
_683747 = _453093_681168 + _683746;
float* _684925;
_684925 = _453093_681168 + _684924;
float* _682116;
_682116 = _453093_681168 + _682115;
float* _683777;
_683777 = _453093_681168 + _683776;
float* _683506;
_683506 = _453093_681168 + _683505;
float* _682056;
_682056 = _453093_681168 + _682055;
float* _682660;
_682660 = _453093_681168 + _682659;
float* _684442;
_684442 = _453093_681168 + _684441;
float* _682509;
_682509 = _453093_681168 + _682508;
float* _683626;
_683626 = _453093_681168 + _683625;
float* _684593;
_684593 = _453093_681168 + _684592;
float* _684623;
_684623 = _453093_681168 + _684622;
float* _684774;
_684774 = _453093_681168 + _684773;
float* _684563;
_684563 = _453093_681168 + _684562;
float* _683143;
_683143 = _453093_681168 + _683142;
float* _683536;
_683536 = _453093_681168 + _683535;
float* _683657;
_683657 = _453093_681168 + _683656;
float* _683324;
_683324 = _453093_681168 + _683323;
float* _683566;
_683566 = _453093_681168 + _683565;
float* _683234;
_683234 = _453093_681168 + _683233;
float* _684955;
_684955 = _453093_681168 + _684954;
float* _683113;
_683113 = _453093_681168 + _683112;
float* _683808;
_683808 = _453093_681168 + _683807;
float* _683204;
_683204 = _453093_681168 + _683203;
float* _683687;
_683687 = _453093_681168 + _683686;
float* _682811;
_682811 = _453093_681168 + _682810;
float* _682479;
_682479 = _453093_681168 + _682478;
float* _683717;
_683717 = _453093_681168 + _683716;
float* _684895;
_684895 = _453093_681168 + _684894;
float* _684351;
_684351 = _453093_681168 + _684350;
float* _683415;
_683415 = _453093_681168 + _683414;
float* _682418;
_682418 = _453093_681168 + _682417;
float* _683838;
_683838 = _453093_681168 + _683837;
float* _684804;
_684804 = _453093_681168 + _684803;
float* _682449;
_682449 = _453093_681168 + _682448;
float* _683596;
_683596 = _453093_681168 + _683595;
float* _684502;
_684502 = _453093_681168 + _684501;
float* _687035;
_687035 = _453093_681168 + _687034;
float* _687030;
_687030 = _453093_681168 + _687029;
float* _687025;
_687025 = _453093_681168 + _687024;
float* _687013;
_687013 = _453093_681168 + _687012;
float* _687019;
_687019 = _453093_681168 + _687018;
float* _683588;
_683588 = _453093_681168 + _683587;
float* _683583;
_683583 = _453093_681168 + _683582;
float* _683578;
_683578 = _453093_681168 + _683577;
float* _687458;
_687458 = _453093_681168 + _687457;
float* _687453;
_687453 = _453093_681168 + _687452;
float* _687448;
_687448 = _453093_681168 + _687447;
float* _687436;
_687436 = _453093_681168 + _687435;
float* _687442;
_687442 = _453093_681168 + _687441;
int _683980;
_683980 = 2 * _683979;
int _683975;
_683975 = 2 * _683974;
int _683970;
_683970 = 2 * _683969;
int _683958;
_683958 = 2 * _683957;
int _683964;
_683964 = 2 * _683963;
int _684010;
_684010 = 2 * _684009;
int _684005;
_684005 = 2 * _684004;
int _684000;
_684000 = 2 * _683999;
int _683988;
_683988 = 2 * _683987;
int _683994;
_683994 = 2 * _683993;
int _684040;
_684040 = 2 * _684039;
int _684035;
_684035 = 2 * _684034;
int _684030;
_684030 = 2 * _684029;
int _684018;
_684018 = 2 * _684017;
int _684024;
_684024 = 2 * _684023;
int _684100;
_684100 = 2 * _684099;
int _684095;
_684095 = 2 * _684094;
int _684090;
_684090 = 2 * _684089;
int _684078;
_684078 = 2 * _684077;
int _684084;
_684084 = 2 * _684083;
int _684070;
_684070 = 2 * _684069;
int _684065;
_684065 = 2 * _684064;
int _684060;
_684060 = 2 * _684059;
int _684048;
_684048 = 2 * _684047;
int _684054;
_684054 = 2 * _684053;
float* _685495;
_685495 = _453093_681168 + _685494;
float* _685490;
_685490 = _453093_681168 + _685489;
float* _685485;
_685485 = _453093_681168 + _685484;
float* _685473;
_685473 = _453093_681168 + _685472;
float* _685479;
_685479 = _453093_681168 + _685478;
int _685312;
_685312 = 2 * _685311;
int _685307;
_685307 = 2 * _685306;
int _685302;
_685302 = 2 * _685301;
int _685252;
_685252 = 2 * _685251;
int _685247;
_685247 = 2 * _685246;
int _685242;
_685242 = 2 * _685241;
int _685192;
_685192 = 2 * _685191;
int _685187;
_685187 = 2 * _685186;
int _685182;
_685182 = 2 * _685181;
int _684342;
_684342 = 2 * _684341;
int _684337;
_684337 = 2 * _684336;
int _684332;
_684332 = 2 * _684331;
int _684320;
_684320 = 2 * _684319;
int _684326;
_684326 = 2 * _684325;
int _684402;
_684402 = 2 * _684401;
int _684397;
_684397 = 2 * _684396;
int _684392;
_684392 = 2 * _684391;
int _684380;
_684380 = 2 * _684379;
int _684386;
_684386 = 2 * _684385;
int _682772;
_682772 = 2 * _682771;
int _682767;
_682767 = 2 * _682766;
int _682762;
_682762 = 2 * _682761;
int _682750;
_682750 = 2 * _682749;
int _682756;
_682756 = 2 * _682755;
int _682892;
_682892 = 2 * _682891;
int _682887;
_682887 = 2 * _682886;
int _682882;
_682882 = 2 * _682881;
int _682870;
_682870 = 2 * _682869;
int _682876;
_682876 = 2 * _682875;
float* _685223;
_685223 = _453093_681168 + _685222;
float* _685218;
_685218 = _453093_681168 + _685217;
float* _685213;
_685213 = _453093_681168 + _685212;
float* _685201;
_685201 = _453093_681168 + _685200;
float* _685207;
_685207 = _453093_681168 + _685206;
float* _684313;
_684313 = _453093_681168 + _684312;
float* _684308;
_684308 = _453093_681168 + _684307;
float* _684303;
_684303 = _453093_681168 + _684302;
float* _684645;
_684645 = _453093_681168 + _684644;
float* _684640;
_684640 = _453093_681168 + _684639;
float* _684635;
_684635 = _453093_681168 + _684634;
int _687306;
_687306 = 2 * _687305;
int _687301;
_687301 = 2 * _687300;
int _687296;
_687296 = 2 * _687295;
int _687396;
_687396 = 2 * _687395;
int _687391;
_687391 = 2 * _687390;
int _687386;
_687386 = 2 * _687385;
int _687426;
_687426 = 2 * _687425;
int _687421;
_687421 = 2 * _687420;
int _687416;
_687416 = 2 * _687415;
float* _686823;
_686823 = _453093_681168 + _686822;
float* _686818;
_686818 = _453093_681168 + _686817;
float* _686813;
_686813 = _453093_681168 + _686812;
float* _686801;
_686801 = _453093_681168 + _686800;
float* _686807;
_686807 = _453093_681168 + _686806;
float* _683346;
_683346 = _453093_681168 + _683345;
float* _683341;
_683341 = _453093_681168 + _683340;
float* _683336;
_683336 = _453093_681168 + _683335;
float* _686763;
_686763 = _453093_681168 + _686762;
float* _686758;
_686758 = _453093_681168 + _686757;
float* _686753;
_686753 = _453093_681168 + _686752;
float* _686741;
_686741 = _453093_681168 + _686740;
float* _686747;
_686747 = _453093_681168 + _686746;
float* _686461;
_686461 = _453093_681168 + _686460;
float* _686456;
_686456 = _453093_681168 + _686455;
float* _686451;
_686451 = _453093_681168 + _686450;
float* _686439;
_686439 = _453093_681168 + _686438;
float* _686445;
_686445 = _453093_681168 + _686444;
float* _684947;
_684947 = _453093_681168 + _684946;
float* _684942;
_684942 = _453093_681168 + _684941;
float* _684937;
_684937 = _453093_681168 + _684936;
int _682409;
_682409 = 2 * _682408;
int _682404;
_682404 = 2 * _682403;
int _682399;
_682399 = 2 * _682398;
int _682387;
_682387 = 2 * _682386;
int _682393;
_682393 = 2 * _682392;
int _682319;
_682319 = 2 * _682318;
int _682314;
_682314 = 2 * _682313;
int _682309;
_682309 = 2 * _682308;
int _682297;
_682297 = 2 * _682296;
int _682303;
_682303 = 2 * _682302;
float* _684373;
_684373 = _453093_681168 + _684372;
float* _684368;
_684368 = _453093_681168 + _684367;
float* _684363;
_684363 = _453093_681168 + _684362;
float* _684357;
_684357 = _453093_681168 + _684356;
float* _687548;
_687548 = _453093_681168 + _687547;
float* _687543;
_687543 = _453093_681168 + _687542;
float* _687538;
_687538 = _453093_681168 + _687537;
float* _687526;
_687526 = _453093_681168 + _687525;
float* _687532;
_687532 = _453093_681168 + _687531;
float* _686521;
_686521 = _453093_681168 + _686520;
float* _686516;
_686516 = _453093_681168 + _686515;
float* _686511;
_686511 = _453093_681168 + _686510;
float* _686499;
_686499 = _453093_681168 + _686498;
float* _686505;
_686505 = _453093_681168 + _686504;
int _685343;
_685343 = 2 * _685342;
int _685338;
_685338 = 2 * _685337;
int _685333;
_685333 = 2 * _685332;
int _685403;
_685403 = 2 * _685402;
int _685398;
_685398 = 2 * _685397;
int _685393;
_685393 = 2 * _685392;
int _685433;
_685433 = 2 * _685432;
int _685428;
_685428 = 2 * _685427;
int _685423;
_685423 = 2 * _685422;
int _685373;
_685373 = 2 * _685372;
int _685368;
_685368 = 2 * _685367;
int _685363;
_685363 = 2 * _685362;
int _685463;
_685463 = 2 * _685462;
int _685458;
_685458 = 2 * _685457;
int _685453;
_685453 = 2 * _685452;
int _682228;
_682228 = 2 * _682227;
int _682223;
_682223 = 2 * _682222;
int _682218;
_682218 = 2 * _682217;
int _682206;
_682206 = 2 * _682205;
int _682212;
_682212 = 2 * _682211;
int _682288;
_682288 = 2 * _682287;
int _682283;
_682283 = 2 * _682282;
int _682278;
_682278 = 2 * _682277;
int _682266;
_682266 = 2 * _682265;
int _682272;
_682272 = 2 * _682271;
int _682258;
_682258 = 2 * _682257;
int _682253;
_682253 = 2 * _682252;
int _682248;
_682248 = 2 * _682247;
int _682236;
_682236 = 2 * _682235;
int _682242;
_682242 = 2 * _682241;
int _682198;
_682198 = 2 * _682197;
int _682193;
_682193 = 2 * _682192;
int _682188;
_682188 = 2 * _682187;
int _682176;
_682176 = 2 * _682175;
int _682182;
_682182 = 2 * _682181;
int _682168;
_682168 = 2 * _682167;
int _682163;
_682163 = 2 * _682162;
int _682158;
_682158 = 2 * _682157;
int _682146;
_682146 = 2 * _682145;
int _682152;
_682152 = 2 * _682151;
int _683013;
_683013 = 2 * _683012;
int _683008;
_683008 = 2 * _683007;
int _683003;
_683003 = 2 * _683002;
int _682991;
_682991 = 2 * _682990;
int _682997;
_682997 = 2 * _682996;
int _682953;
_682953 = 2 * _682952;
int _682948;
_682948 = 2 * _682947;
int _682943;
_682943 = 2 * _682942;
int _682931;
_682931 = 2 * _682930;
int _682937;
_682937 = 2 * _682936;
int _682923;
_682923 = 2 * _682922;
int _682918;
_682918 = 2 * _682917;
int _682913;
_682913 = 2 * _682912;
int _682901;
_682901 = 2 * _682900;
int _682907;
_682907 = 2 * _682906;
int _682983;
_682983 = 2 * _682982;
int _682978;
_682978 = 2 * _682977;
int _682973;
_682973 = 2 * _682972;
int _682961;
_682961 = 2 * _682960;
int _682967;
_682967 = 2 * _682966;
int _683043;
_683043 = 2 * _683042;
int _683038;
_683038 = 2 * _683037;
int _683033;
_683033 = 2 * _683032;
int _683021;
_683021 = 2 * _683020;
int _683027;
_683027 = 2 * _683026;
float* _684736;
_684736 = _453093_681168 + _684735;
float* _684731;
_684731 = _453093_681168 + _684730;
float* _684726;
_684726 = _453093_681168 + _684725;
float* _684720;
_684720 = _453093_681168 + _684719;
float* _682501;
_682501 = _453093_681168 + _682500;
float* _682496;
_682496 = _453093_681168 + _682495;
float* _682491;
_682491 = _453093_681168 + _682490;
float* _682485;
_682485 = _453093_681168 + _682484;
int _686339;
_686339 = 2 * _686338;
int _686334;
_686334 = 2 * _686333;
int _686329;
_686329 = 2 * _686328;
int _686249;
_686249 = 2 * _686248;
int _686244;
_686244 = 2 * _686243;
int _686239;
_686239 = 2 * _686238;
int _686369;
_686369 = 2 * _686368;
int _686364;
_686364 = 2 * _686363;
int _686359;
_686359 = 2 * _686358;
int _686279;
_686279 = 2 * _686278;
int _686274;
_686274 = 2 * _686273;
int _686269;
_686269 = 2 * _686268;
float* _683528;
_683528 = _453093_681168 + _683527;
float* _683523;
_683523 = _453093_681168 + _683522;
float* _683518;
_683518 = _453093_681168 + _683517;
float* _683512;
_683512 = _453093_681168 + _683511;
int _682741;
_682741 = 2 * _682740;
int _682736;
_682736 = 2 * _682735;
int _682731;
_682731 = 2 * _682730;
int _682719;
_682719 = 2 * _682718;
int _682725;
_682725 = 2 * _682724;
int _682621;
_682621 = 2 * _682620;
int _682616;
_682616 = 2 * _682615;
int _682611;
_682611 = 2 * _682610;
int _682599;
_682599 = 2 * _682598;
int _682605;
_682605 = 2 * _682604;
int _682711;
_682711 = 2 * _682710;
int _682706;
_682706 = 2 * _682705;
int _682701;
_682701 = 2 * _682700;
int _682689;
_682689 = 2 * _682688;
int _682695;
_682695 = 2 * _682694;
int _682651;
_682651 = 2 * _682650;
int _682646;
_682646 = 2 * _682645;
int _682641;
_682641 = 2 * _682640;
int _682629;
_682629 = 2 * _682628;
int _682635;
_682635 = 2 * _682634;
float* _685283;
_685283 = _453093_681168 + _685282;
float* _685278;
_685278 = _453093_681168 + _685277;
float* _685273;
_685273 = _453093_681168 + _685272;
float* _685261;
_685261 = _453093_681168 + _685260;
float* _685267;
_685267 = _453093_681168 + _685266;
int _687849;
_687849 = 2 * _687848;
int _687844;
_687844 = 2 * _687843;
int _687839;
_687839 = 2 * _687838;
int _687879;
_687879 = 2 * _687878;
int _687874;
_687874 = 2 * _687873;
int _687869;
_687869 = 2 * _687868;
int _687819;
_687819 = 2 * _687818;
int _687814;
_687814 = 2 * _687813;
int _687809;
_687809 = 2 * _687808;
float* _687518;
_687518 = _453093_681168 + _687517;
float* _687513;
_687513 = _453093_681168 + _687512;
float* _687508;
_687508 = _453093_681168 + _687507;
float* _687496;
_687496 = _453093_681168 + _687495;
float* _687502;
_687502 = _453093_681168 + _687501;
float* _686642;
_686642 = _453093_681168 + _686641;
float* _686637;
_686637 = _453093_681168 + _686636;
float* _686632;
_686632 = _453093_681168 + _686631;
float* _686620;
_686620 = _453093_681168 + _686619;
float* _686626;
_686626 = _453093_681168 + _686625;
float* _684977;
_684977 = _453093_681168 + _684976;
float* _684972;
_684972 = _453093_681168 + _684971;
float* _684967;
_684967 = _453093_681168 + _684966;
float* _684961;
_684961 = _453093_681168 + _684960;
int _682107;
_682107 = 2 * _682106;
int _682102;
_682102 = 2 * _682101;
int _682097;
_682097 = 2 * _682096;
int _682085;
_682085 = 2 * _682084;
int _682091;
_682091 = 2 * _682090;
int _682047;
_682047 = 2 * _682046;
int _682042;
_682042 = 2 * _682041;
int _682037;
_682037 = 2 * _682036;
int _682025;
_682025 = 2 * _682024;
int _682031;
_682031 = 2 * _682030;
int _682017;
_682017 = 2 * _682016;
int _682011;
_682011 = 2 * _682010;
int _682006;
_682006 = 2 * _682005;
int _681993;
_681993 = 2 * _681992;
int _682000;
_682000 = 2 * _681999;
int _686037;
_686037 = 2 * _686036;
int _686032;
_686032 = 2 * _686031;
int _686027;
_686027 = 2 * _686026;
int _685947;
_685947 = 2 * _685946;
int _685942;
_685942 = 2 * _685941;
int _685937;
_685937 = 2 * _685936;
int _686067;
_686067 = 2 * _686066;
int _686062;
_686062 = 2 * _686061;
int _686057;
_686057 = 2 * _686056;
float* _686401;
_686401 = _453093_681168 + _686400;
float* _686396;
_686396 = _453093_681168 + _686395;
float* _686391;
_686391 = _453093_681168 + _686390;
float* _686379;
_686379 = _453093_681168 + _686378;
float* _686385;
_686385 = _453093_681168 + _686384;
int _687970;
_687970 = 2 * _687969;
int _687965;
_687965 = 2 * _687964;
int _687960;
_687960 = 2 * _687959;
int _688000;
_688000 = 2 * _687999;
int _687995;
_687995 = 2 * _687994;
int _687990;
_687990 = 2 * _687989;
int _687940;
_687940 = 2 * _687939;
int _687935;
_687935 = 2 * _687934;
int _687930;
_687930 = 2 * _687929;
int _687910;
_687910 = 2 * _687909;
int _687905;
_687905 = 2 * _687904;
int _687900;
_687900 = 2 * _687899;
float* _686431;
_686431 = _453093_681168 + _686430;
float* _686426;
_686426 = _453093_681168 + _686425;
float* _686421;
_686421 = _453093_681168 + _686420;
float* _686409;
_686409 = _453093_681168 + _686408;
float* _686415;
_686415 = _453093_681168 + _686414;
float* _683860;
_683860 = _453093_681168 + _683859;
float* _683855;
_683855 = _453093_681168 + _683854;
float* _683850;
_683850 = _453093_681168 + _683849;
float* _683844;
_683844 = _453093_681168 + _683843;
float* _683256;
_683256 = _453093_681168 + _683255;
float* _683251;
_683251 = _453093_681168 + _683250;
float* _683246;
_683246 = _453093_681168 + _683245;
float* _683240;
_683240 = _453093_681168 + _683239;
int _684433;
_684433 = 2 * _684432;
int _684428;
_684428 = 2 * _684427;
int _684423;
_684423 = 2 * _684422;
int _684411;
_684411 = 2 * _684410;
int _684417;
_684417 = 2 * _684416;
int _684493;
_684493 = 2 * _684492;
int _684488;
_684488 = 2 * _684487;
int _684483;
_684483 = 2 * _684482;
int _684471;
_684471 = 2 * _684470;
int _684477;
_684477 = 2 * _684476;
int _684553;
_684553 = 2 * _684552;
int _684548;
_684548 = 2 * _684547;
int _684543;
_684543 = 2 * _684542;
int _684531;
_684531 = 2 * _684530;
int _684537;
_684537 = 2 * _684536;
int _683104;
_683104 = 2 * _683103;
int _683099;
_683099 = 2 * _683098;
int _683094;
_683094 = 2 * _683093;
int _683082;
_683082 = 2 * _683081;
int _683088;
_683088 = 2 * _683087;
int _683074;
_683074 = 2 * _683073;
int _683069;
_683069 = 2 * _683068;
int _683064;
_683064 = 2 * _683063;
int _683052;
_683052 = 2 * _683051;
int _683058;
_683058 = 2 * _683057;
int _683194;
_683194 = 2 * _683193;
int _683189;
_683189 = 2 * _683188;
int _683184;
_683184 = 2 * _683183;
int _683172;
_683172 = 2 * _683171;
int _683178;
_683178 = 2 * _683177;
float* _683558;
_683558 = _453093_681168 + _683557;
float* _683553;
_683553 = _453093_681168 + _683552;
float* _683548;
_683548 = _453093_681168 + _683547;
float* _683542;
_683542 = _453093_681168 + _683541;
float* _685615;
_685615 = _453093_681168 + _685614;
float* _685610;
_685610 = _453093_681168 + _685609;
float* _685605;
_685605 = _453093_681168 + _685604;
float* _685593;
_685593 = _453093_681168 + _685592;
float* _685599;
_685599 = _453093_681168 + _685598;
float* _685585;
_685585 = _453093_681168 + _685584;
float* _685580;
_685580 = _453093_681168 + _685579;
float* _685575;
_685575 = _453093_681168 + _685574;
float* _685563;
_685563 = _453093_681168 + _685562;
float* _685569;
_685569 = _453093_681168 + _685568;
float* _686008;
_686008 = _453093_681168 + _686007;
float* _686003;
_686003 = _453093_681168 + _686002;
float* _685998;
_685998 = _453093_681168 + _685997;
float* _685986;
_685986 = _453093_681168 + _685985;
float* _685992;
_685992 = _453093_681168 + _685991;
float* _683135;
_683135 = _453093_681168 + _683134;
float* _683130;
_683130 = _453093_681168 + _683129;
float* _683125;
_683125 = _453093_681168 + _683124;
float* _683119;
_683119 = _453093_681168 + _683118;
float* _684675;
_684675 = _453093_681168 + _684674;
float* _684670;
_684670 = _453093_681168 + _684669;
float* _684665;
_684665 = _453093_681168 + _684664;
float* _684659;
_684659 = _453093_681168 + _684658;
float* _687760;
_687760 = _453093_681168 + _687759;
float* _687755;
_687755 = _453093_681168 + _687754;
float* _687750;
_687750 = _453093_681168 + _687749;
float* _687738;
_687738 = _453093_681168 + _687737;
float* _687744;
_687744 = _453093_681168 + _687743;
float* _683709;
_683709 = _453093_681168 + _683708;
float* _683704;
_683704 = _453093_681168 + _683703;
float* _683699;
_683699 = _453093_681168 + _683698;
float* _683693;
_683693 = _453093_681168 + _683692;
float* _682138;
_682138 = _453093_681168 + _682137;
float* _682133;
_682133 = _453093_681168 + _682132;
float* _682128;
_682128 = _453093_681168 + _682127;
float* _682122;
_682122 = _453093_681168 + _682121;
float* _682078;
_682078 = _453093_681168 + _682077;
float* _682073;
_682073 = _453093_681168 + _682072;
float* _682068;
_682068 = _453093_681168 + _682067;
float* _682062;
_682062 = _453093_681168 + _682061;
float* _682682;
_682682 = _453093_681168 + _682681;
float* _682677;
_682677 = _453093_681168 + _682676;
float* _682672;
_682672 = _453093_681168 + _682671;
float* _682666;
_682666 = _453093_681168 + _682665;
float* _683679;
_683679 = _453093_681168 + _683678;
float* _683674;
_683674 = _453093_681168 + _683673;
float* _683669;
_683669 = _453093_681168 + _683668;
float* _683663;
_683663 = _453093_681168 + _683662;
float* _687337;
_687337 = _453093_681168 + _687336;
float* _687332;
_687332 = _453093_681168 + _687331;
float* _687327;
_687327 = _453093_681168 + _687326;
float* _687315;
_687315 = _453093_681168 + _687314;
float* _687321;
_687321 = _453093_681168 + _687320;
float* _686310;
_686310 = _453093_681168 + _686309;
float* _686305;
_686305 = _453093_681168 + _686304;
float* _686300;
_686300 = _453093_681168 + _686299;
float* _686288;
_686288 = _453093_681168 + _686287;
float* _686294;
_686294 = _453093_681168 + _686293;
float* _682440;
_682440 = _453093_681168 + _682439;
float* _682435;
_682435 = _453093_681168 + _682434;
float* _682430;
_682430 = _453093_681168 + _682429;
float* _682424;
_682424 = _453093_681168 + _682423;
float* _682833;
_682833 = _453093_681168 + _682832;
float* _682828;
_682828 = _453093_681168 + _682827;
float* _682823;
_682823 = _453093_681168 + _682822;
float* _682817;
_682817 = _453093_681168 + _682816;
int _687668;
_687668 = 2 * _687667;
int _687663;
_687663 = 2 * _687662;
int _687658;
_687658 = 2 * _687657;
int _687638;
_687638 = 2 * _687637;
int _687633;
_687633 = 2 * _687632;
int _687628;
_687628 = 2 * _687627;
int _687698;
_687698 = 2 * _687697;
int _687693;
_687693 = 2 * _687692;
int _687688;
_687688 = 2 * _687687;
int _687608;
_687608 = 2 * _687607;
int _687603;
_687603 = 2 * _687602;
int _687598;
_687598 = 2 * _687597;
int _687728;
_687728 = 2 * _687727;
int _687723;
_687723 = 2 * _687722;
int _687718;
_687718 = 2 * _687717;
float* _685525;
_685525 = _453093_681168 + _685524;
float* _685520;
_685520 = _453093_681168 + _685519;
float* _685515;
_685515 = _453093_681168 + _685514;
float* _685503;
_685503 = _453093_681168 + _685502;
float* _685509;
_685509 = _453093_681168 + _685508;
float* _687367;
_687367 = _453093_681168 + _687366;
float* _687362;
_687362 = _453093_681168 + _687361;
float* _687357;
_687357 = _453093_681168 + _687356;
float* _687345;
_687345 = _453093_681168 + _687344;
float* _687351;
_687351 = _453093_681168 + _687350;
float* _683226;
_683226 = _453093_681168 + _683225;
float* _683221;
_683221 = _453093_681168 + _683220;
float* _683216;
_683216 = _453093_681168 + _683215;
float* _683210;
_683210 = _453093_681168 + _683209;
float* _684464;
_684464 = _453093_681168 + _684463;
float* _684459;
_684459 = _453093_681168 + _684458;
float* _684454;
_684454 = _453093_681168 + _684453;
float* _684448;
_684448 = _453093_681168 + _684447;
float* _687125;
_687125 = _453093_681168 + _687124;
float* _687120;
_687120 = _453093_681168 + _687119;
float* _687115;
_687115 = _453093_681168 + _687114;
float* _687103;
_687103 = _453093_681168 + _687102;
float* _687109;
_687109 = _453093_681168 + _687108;
float* _686884;
_686884 = _453093_681168 + _686883;
float* _686879;
_686879 = _453093_681168 + _686878;
float* _686874;
_686874 = _453093_681168 + _686873;
float* _686862;
_686862 = _453093_681168 + _686861;
float* _686868;
_686868 = _453093_681168 + _686867;
float* _687186;
_687186 = _453093_681168 + _687185;
float* _687181;
_687181 = _453093_681168 + _687180;
float* _687176;
_687176 = _453093_681168 + _687175;
float* _687164;
_687164 = _453093_681168 + _687163;
float* _687170;
_687170 = _453093_681168 + _687169;
float* _683165;
_683165 = _453093_681168 + _683164;
float* _683160;
_683160 = _453093_681168 + _683159;
float* _683155;
_683155 = _453093_681168 + _683154;
float* _683149;
_683149 = _453093_681168 + _683148;
int _685916;
_685916 = 2 * _685915;
int _685911;
_685911 = 2 * _685910;
int _685906;
_685906 = 2 * _685905;
int _685796;
_685796 = 2 * _685795;
int _685791;
_685791 = 2 * _685790;
int _685786;
_685786 = 2 * _685785;
int _685886;
_685886 = 2 * _685885;
int _685881;
_685881 = 2 * _685880;
int _685876;
_685876 = 2 * _685875;
int _685826;
_685826 = 2 * _685825;
int _685821;
_685821 = 2 * _685820;
int _685816;
_685816 = 2 * _685815;
float* _684826;
_684826 = _453093_681168 + _684825;
float* _684821;
_684821 = _453093_681168 + _684820;
float* _684816;
_684816 = _453093_681168 + _684815;
float* _684810;
_684810 = _453093_681168 + _684809;
float* _683648;
_683648 = _453093_681168 + _683647;
float* _683643;
_683643 = _453093_681168 + _683642;
float* _683638;
_683638 = _453093_681168 + _683637;
float* _683632;
_683632 = _453093_681168 + _683631;
float* _682531;
_682531 = _453093_681168 + _682530;
float* _682526;
_682526 = _453093_681168 + _682525;
float* _682521;
_682521 = _453093_681168 + _682520;
float* _682515;
_682515 = _453093_681168 + _682514;
float* _687488;
_687488 = _453093_681168 + _687487;
float* _687483;
_687483 = _453093_681168 + _687482;
float* _687478;
_687478 = _453093_681168 + _687477;
float* _687466;
_687466 = _453093_681168 + _687465;
float* _687472;
_687472 = _453093_681168 + _687471;
float* _685676;
_685676 = _453093_681168 + _685675;
float* _685671;
_685671 = _453093_681168 + _685670;
float* _685666;
_685666 = _453093_681168 + _685665;
float* _685654;
_685654 = _453093_681168 + _685653;
float* _685660;
_685660 = _453093_681168 + _685659;
int _685101;
_685101 = 2 * _685100;
int _685096;
_685096 = 2 * _685095;
int _685091;
_685091 = 2 * _685090;
int _685161;
_685161 = 2 * _685160;
int _685156;
_685156 = 2 * _685155;
int _685151;
_685151 = 2 * _685150;
int _685131;
_685131 = 2 * _685130;
int _685126;
_685126 = 2 * _685125;
int _685121;
_685121 = 2 * _685120;
int _685041;
_685041 = 2 * _685040;
int _685035;
_685035 = 2 * _685034;
int _685030;
_685030 = 2 * _685029;
int _685071;
_685071 = 2 * _685070;
int _685066;
_685066 = 2 * _685065;
int _685061;
_685061 = 2 * _685060;
float* _684524;
_684524 = _453093_681168 + _684523;
float* _684519;
_684519 = _453093_681168 + _684518;
float* _684514;
_684514 = _453093_681168 + _684513;
float* _684508;
_684508 = _453093_681168 + _684507;
int _683406;
_683406 = 2 * _683405;
int _683401;
_683401 = 2 * _683400;
int _683396;
_683396 = 2 * _683395;
int _683384;
_683384 = 2 * _683383;
int _683390;
_683390 = 2 * _683389;
int _683496;
_683496 = 2 * _683495;
int _683491;
_683491 = 2 * _683490;
int _683486;
_683486 = 2 * _683485;
int _683474;
_683474 = 2 * _683473;
int _683480;
_683480 = 2 * _683479;
int _683466;
_683466 = 2 * _683465;
int _683461;
_683461 = 2 * _683460;
int _683456;
_683456 = 2 * _683455;
int _683444;
_683444 = 2 * _683443;
int _683450;
_683450 = 2 * _683449;
int _683376;
_683376 = 2 * _683375;
int _683371;
_683371 = 2 * _683370;
int _683366;
_683366 = 2 * _683365;
int _683354;
_683354 = 2 * _683353;
int _683360;
_683360 = 2 * _683359;
float* _685978;
_685978 = _453093_681168 + _685977;
float* _685973;
_685973 = _453093_681168 + _685972;
float* _685968;
_685968 = _453093_681168 + _685967;
float* _685956;
_685956 = _453093_681168 + _685955;
float* _685962;
_685962 = _453093_681168 + _685961;
float* _685857;
_685857 = _453093_681168 + _685856;
float* _685852;
_685852 = _453093_681168 + _685851;
float* _685847;
_685847 = _453093_681168 + _685846;
float* _685835;
_685835 = _453093_681168 + _685834;
float* _685841;
_685841 = _453093_681168 + _685840;
float* _683618;
_683618 = _453093_681168 + _683617;
float* _683613;
_683613 = _453093_681168 + _683612;
float* _683608;
_683608 = _453093_681168 + _683607;
float* _683602;
_683602 = _453093_681168 + _683601;
float* _683799;
_683799 = _453093_681168 + _683798;
float* _683794;
_683794 = _453093_681168 + _683793;
float* _683789;
_683789 = _453093_681168 + _683788;
float* _683783;
_683783 = _453093_681168 + _683782;
int _686188;
_686188 = 2 * _686187;
int _686183;
_686183 = 2 * _686182;
int _686178;
_686178 = 2 * _686177;
int _686128;
_686128 = 2 * _686127;
int _686123;
_686123 = 2 * _686122;
int _686118;
_686118 = 2 * _686117;
int _686098;
_686098 = 2 * _686097;
int _686093;
_686093 = 2 * _686092;
int _686088;
_686088 = 2 * _686087;
int _686218;
_686218 = 2 * _686217;
int _686213;
_686213 = 2 * _686212;
int _686208;
_686208 = 2 * _686207;
int _686158;
_686158 = 2 * _686157;
int _686153;
_686153 = 2 * _686152;
int _686148;
_686148 = 2 * _686147;
float* _683437;
_683437 = _453093_681168 + _683436;
float* _683432;
_683432 = _453093_681168 + _683431;
float* _683427;
_683427 = _453093_681168 + _683426;
float* _683421;
_683421 = _453093_681168 + _683420;
float* _688031;
_688031 = _453093_681168 + _688030;
float* _688026;
_688026 = _453093_681168 + _688025;
float* _688021;
_688021 = _453093_681168 + _688020;
float* _688015;
_688015 = _453093_681168 + _688014;
float* _688009;
_688009 = _453093_681168 + _688008;
float* _687790;
_687790 = _453093_681168 + _687789;
float* _687785;
_687785 = _453093_681168 + _687784;
float* _687780;
_687780 = _453093_681168 + _687779;
float* _687768;
_687768 = _453093_681168 + _687767;
float* _687774;
_687774 = _453093_681168 + _687773;
float* _686733;
_686733 = _453093_681168 + _686732;
float* _686728;
_686728 = _453093_681168 + _686727;
float* _686723;
_686723 = _453093_681168 + _686722;
float* _686711;
_686711 = _453093_681168 + _686710;
float* _686717;
_686717 = _453093_681168 + _686716;
int _684221;
_684221 = 2 * _684220;
int _684216;
_684216 = 2 * _684215;
int _684211;
_684211 = 2 * _684210;
int _684199;
_684199 = 2 * _684198;
int _684205;
_684205 = 2 * _684204;
int _684251;
_684251 = 2 * _684250;
int _684246;
_684246 = 2 * _684245;
int _684241;
_684241 = 2 * _684240;
int _684229;
_684229 = 2 * _684228;
int _684235;
_684235 = 2 * _684234;
int _684131;
_684131 = 2 * _684130;
int _684126;
_684126 = 2 * _684125;
int _684121;
_684121 = 2 * _684120;
int _684109;
_684109 = 2 * _684108;
int _684115;
_684115 = 2 * _684114;
int _684191;
_684191 = 2 * _684190;
int _684186;
_684186 = 2 * _684185;
int _684181;
_684181 = 2 * _684180;
int _684169;
_684169 = 2 * _684168;
int _684175;
_684175 = 2 * _684174;
int _684161;
_684161 = 2 * _684160;
int _684156;
_684156 = 2 * _684155;
int _684151;
_684151 = 2 * _684150;
int _684139;
_684139 = 2 * _684138;
int _684145;
_684145 = 2 * _684144;
float* _683769;
_683769 = _453093_681168 + _683768;
float* _683764;
_683764 = _453093_681168 + _683763;
float* _683759;
_683759 = _453093_681168 + _683758;
float* _683753;
_683753 = _453093_681168 + _683752;
float* _684796;
_684796 = _453093_681168 + _684795;
float* _684791;
_684791 = _453093_681168 + _684790;
float* _684786;
_684786 = _453093_681168 + _684785;
float* _684780;
_684780 = _453093_681168 + _684779;
float* _682471;
_682471 = _453093_681168 + _682470;
float* _682466;
_682466 = _453093_681168 + _682465;
float* _682461;
_682461 = _453093_681168 + _682460;
float* _682455;
_682455 = _453093_681168 + _682454;
float* _686914;
_686914 = _453093_681168 + _686913;
float* _686909;
_686909 = _453093_681168 + _686908;
float* _686904;
_686904 = _453093_681168 + _686903;
float* _686892;
_686892 = _453093_681168 + _686891;
float* _686898;
_686898 = _453093_681168 + _686897;
float* _686974;
_686974 = _453093_681168 + _686973;
float* _686969;
_686969 = _453093_681168 + _686968;
float* _686964;
_686964 = _453093_681168 + _686963;
float* _686952;
_686952 = _453093_681168 + _686951;
float* _686958;
_686958 = _453093_681168 + _686957;
float* _686944;
_686944 = _453093_681168 + _686943;
float* _686939;
_686939 = _453093_681168 + _686938;
float* _686934;
_686934 = _453093_681168 + _686933;
float* _686922;
_686922 = _453093_681168 + _686921;
float* _686928;
_686928 = _453093_681168 + _686927;
float* _686491;
_686491 = _453093_681168 + _686490;
float* _686486;
_686486 = _453093_681168 + _686485;
float* _686481;
_686481 = _453093_681168 + _686480;
float* _686469;
_686469 = _453093_681168 + _686468;
float* _686475;
_686475 = _453093_681168 + _686474;
float* _683830;
_683830 = _453093_681168 + _683829;
float* _683825;
_683825 = _453093_681168 + _683824;
float* _683820;
_683820 = _453093_681168 + _683819;
float* _683814;
_683814 = _453093_681168 + _683813;
float* _687246;
_687246 = _453093_681168 + _687245;
float* _687241;
_687241 = _453093_681168 + _687240;
float* _687236;
_687236 = _453093_681168 + _687235;
float* _687224;
_687224 = _453093_681168 + _687223;
float* _687230;
_687230 = _453093_681168 + _687229;
float* _687276;
_687276 = _453093_681168 + _687275;
float* _687271;
_687271 = _453093_681168 + _687270;
float* _687266;
_687266 = _453093_681168 + _687265;
float* _687254;
_687254 = _453093_681168 + _687253;
float* _687260;
_687260 = _453093_681168 + _687259;
float* _687216;
_687216 = _453093_681168 + _687215;
float* _687211;
_687211 = _453093_681168 + _687210;
float* _687206;
_687206 = _453093_681168 + _687205;
float* _687194;
_687194 = _453093_681168 + _687193;
float* _687200;
_687200 = _453093_681168 + _687199;
float* _684585;
_684585 = _453093_681168 + _684584;
float* _684580;
_684580 = _453093_681168 + _684579;
float* _684575;
_684575 = _453093_681168 + _684574;
float* _684569;
_684569 = _453093_681168 + _684568;
float* _685007;
_685007 = _453093_681168 + _685006;
float* _685002;
_685002 = _453093_681168 + _685001;
float* _684997;
_684997 = _453093_681168 + _684996;
float* _684991;
_684991 = _453093_681168 + _684990;
float* _684917;
_684917 = _453093_681168 + _684916;
float* _684912;
_684912 = _453093_681168 + _684911;
float* _684907;
_684907 = _453093_681168 + _684906;
float* _684901;
_684901 = _453093_681168 + _684900;
float* _687578;
_687578 = _453093_681168 + _687577;
float* _687573;
_687573 = _453093_681168 + _687572;
float* _687568;
_687568 = _453093_681168 + _687567;
float* _687556;
_687556 = _453093_681168 + _687555;
float* _687562;
_687562 = _453093_681168 + _687561;
float* _685706;
_685706 = _453093_681168 + _685705;
float* _685701;
_685701 = _453093_681168 + _685700;
float* _685696;
_685696 = _453093_681168 + _685695;
float* _685684;
_685684 = _453093_681168 + _685683;
float* _685690;
_685690 = _453093_681168 + _685689;
float* _685736;
_685736 = _453093_681168 + _685735;
float* _685731;
_685731 = _453093_681168 + _685730;
float* _685726;
_685726 = _453093_681168 + _685725;
float* _685714;
_685714 = _453093_681168 + _685713;
float* _685720;
_685720 = _453093_681168 + _685719;
float* _686793;
_686793 = _453093_681168 + _686792;
float* _686788;
_686788 = _453093_681168 + _686787;
float* _686783;
_686783 = _453093_681168 + _686782;
float* _686771;
_686771 = _453093_681168 + _686770;
float* _686777;
_686777 = _453093_681168 + _686776;
float* _686703;
_686703 = _453093_681168 + _686702;
float* _686698;
_686698 = _453093_681168 + _686697;
float* _686693;
_686693 = _453093_681168 + _686692;
float* _686681;
_686681 = _453093_681168 + _686680;
float* _686687;
_686687 = _453093_681168 + _686686;
float* _686672;
_686672 = _453093_681168 + _686671;
float* _686667;
_686667 = _453093_681168 + _686666;
float* _686662;
_686662 = _453093_681168 + _686661;
float* _686650;
_686650 = _453093_681168 + _686649;
float* _686656;
_686656 = _453093_681168 + _686655;
float* _686612;
_686612 = _453093_681168 + _686611;
float* _686607;
_686607 = _453093_681168 + _686606;
float* _686602;
_686602 = _453093_681168 + _686601;
float* _686590;
_686590 = _453093_681168 + _686589;
float* _686596;
_686596 = _453093_681168 + _686595;
float* _686582;
_686582 = _453093_681168 + _686581;
float* _686577;
_686577 = _453093_681168 + _686576;
float* _686572;
_686572 = _453093_681168 + _686571;
float* _686560;
_686560 = _453093_681168 + _686559;
float* _686566;
_686566 = _453093_681168 + _686565;
float* _686022;
_686022 = _453093_681168 + _686021;
float* _685871;
_685871 = _453093_681168 + _685870;
float* _685086;
_685086 = _453093_681168 + _685085;
float* _687653;
_687653 = _453093_681168 + _687652;
float* _685932;
_685932 = _453093_681168 + _685931;
float* _687985;
_687985 = _453093_681168 + _687984;
float* _686083;
_686083 = _453093_681168 + _686082;
float* _685811;
_685811 = _453093_681168 + _685810;
float* _687079;
_687079 = _453093_681168 + _687078;
float* _687864;
_687864 = _453093_681168 + _687863;
float* _687925;
_687925 = _453093_681168 + _687924;
float* _685056;
_685056 = _453093_681168 + _685055;
float* _687140;
_687140 = _453093_681168 + _687139;
float* _687955;
_687955 = _453093_681168 + _687954;
float* _685116;
_685116 = _453093_681168 + _685115;
float* _685539;
_685539 = _453093_681168 + _685538;
float* _687895;
_687895 = _453093_681168 + _687894;
float* _687291;
_687291 = _453093_681168 + _687290;
float* _685418;
_685418 = _453093_681168 + _685417;
float* _687049;
_687049 = _453093_681168 + _687048;
float* _685237;
_685237 = _453093_681168 + _685236;
float* _686324;
_686324 = _453093_681168 + _686323;
float* _686173;
_686173 = _453093_681168 + _686172;
float* _686143;
_686143 = _453093_681168 + _686142;
float* _686838;
_686838 = _453093_681168 + _686837;
float* _685630;
_685630 = _453093_681168 + _685629;
float* _685146;
_685146 = _453093_681168 + _685145;
float* _687623;
_687623 = _453093_681168 + _687622;
float* _687411;
_687411 = _453093_681168 + _687410;
float* _687834;
_687834 = _453093_681168 + _687833;
float* _687593;
_687593 = _453093_681168 + _687592;
float* _687804;
_687804 = _453093_681168 + _687803;
float* _687683;
_687683 = _453093_681168 + _687682;
float* _685328;
_685328 = _453093_681168 + _685327;
float* _687381;
_687381 = _453093_681168 + _687380;
float* _686113;
_686113 = _453093_681168 + _686112;
float* _685358;
_685358 = _453093_681168 + _685357;
float* _685781;
_685781 = _453093_681168 + _685780;
float* _686354;
_686354 = _453093_681168 + _686353;
float* _686203;
_686203 = _453093_681168 + _686202;
float* _685448;
_685448 = _453093_681168 + _685447;
float* _686536;
_686536 = _453093_681168 + _686535;
float* _685177;
_685177 = _453093_681168 + _685176;
float* _685750;
_685750 = _453093_681168 + _685749;
float* _685388;
_685388 = _453093_681168 + _685387;
float* _686234;
_686234 = _453093_681168 + _686233;
float* _687713;
_687713 = _453093_681168 + _687712;
float* _685901;
_685901 = _453093_681168 + _685900;
float* _686264;
_686264 = _453093_681168 + _686263;
float* _685025;
_685025 = _453093_681168 + _685024;
float* _686989;
_686989 = _453093_681168 + _686988;
float* _685297;
_685297 = _453093_681168 + _685296;
float* _686052;
_686052 = _453093_681168 + _686051;
float* _686318;
_686318 = _453093_681168 + _686317;
float* _685171;
_685171 = _453093_681168 + _685170;
float* _687587;
_687587 = _453093_681168 + _687586;
float* _687134;
_687134 = _453093_681168 + _687133;
float* _687285;
_687285 = _453093_681168 + _687284;
float* _687677;
_687677 = _453093_681168 + _687676;
float* _686832;
_686832 = _453093_681168 + _686831;
float* _685291;
_685291 = _453093_681168 + _685290;
float* _685050;
_685050 = _453093_681168 + _685049;
float* _685744;
_685744 = _453093_681168 + _685743;
float* _685865;
_685865 = _453093_681168 + _685864;
float* _685352;
_685352 = _453093_681168 + _685351;
float* _685624;
_685624 = _453093_681168 + _685623;
float* _685110;
_685110 = _453093_681168 + _685109;
float* _687858;
_687858 = _453093_681168 + _687857;
float* _687617;
_687617 = _453093_681168 + _687616;
float* _686228;
_686228 = _453093_681168 + _686227;
float* _686137;
_686137 = _453093_681168 + _686136;
float* _686016;
_686016 = _453093_681168 + _686015;
float* _685140;
_685140 = _453093_681168 + _685139;
float* _686530;
_686530 = _453093_681168 + _686529;
float* _685231;
_685231 = _453093_681168 + _685230;
float* _685895;
_685895 = _453093_681168 + _685894;
float* _686046;
_686046 = _453093_681168 + _686045;
float* _687949;
_687949 = _453093_681168 + _687948;
float* _685442;
_685442 = _453093_681168 + _685441;
float* _687043;
_687043 = _453093_681168 + _687042;
float* _686107;
_686107 = _453093_681168 + _686106;
float* _687073;
_687073 = _453093_681168 + _687072;
float* _685018;
_685018 = _453093_681168 + _685017;
float* _686197;
_686197 = _453093_681168 + _686196;
float* _686167;
_686167 = _453093_681168 + _686166;
float* _686077;
_686077 = _453093_681168 + _686076;
float* _687828;
_687828 = _453093_681168 + _687827;
float* _686348;
_686348 = _453093_681168 + _686347;
float* _687919;
_687919 = _453093_681168 + _687918;
float* _687979;
_687979 = _453093_681168 + _687978;
float* _686258;
_686258 = _453093_681168 + _686257;
float* _685805;
_685805 = _453093_681168 + _685804;
float* _685412;
_685412 = _453093_681168 + _685411;
float* _685080;
_685080 = _453093_681168 + _685079;
float* _687798;
_687798 = _453093_681168 + _687797;
float* _685382;
_685382 = _453093_681168 + _685381;
float* _687647;
_687647 = _453093_681168 + _687646;
float* _687375;
_687375 = _453093_681168 + _687374;
float* _687405;
_687405 = _453093_681168 + _687404;
float* _685926;
_685926 = _453093_681168 + _685925;
float* _685322;
_685322 = _453093_681168 + _685321;
float* _685775;
_685775 = _453093_681168 + _685774;
float* _686983;
_686983 = _453093_681168 + _686982;
float* _687707;
_687707 = _453093_681168 + _687706;
float* _687889;
_687889 = _453093_681168 + _687888;
float* _685533;
_685533 = _453093_681168 + _685532;
float* _683981;
_683981 = _453093_681168 + _683980;
float* _683976;
_683976 = _453093_681168 + _683975;
float* _683971;
_683971 = _453093_681168 + _683970;
float* _683959;
_683959 = _453093_681168 + _683958;
float* _683965;
_683965 = _453093_681168 + _683964;
float* _684011;
_684011 = _453093_681168 + _684010;
float* _684006;
_684006 = _453093_681168 + _684005;
float* _684001;
_684001 = _453093_681168 + _684000;
float* _683989;
_683989 = _453093_681168 + _683988;
float* _683995;
_683995 = _453093_681168 + _683994;
float* _684041;
_684041 = _453093_681168 + _684040;
float* _684036;
_684036 = _453093_681168 + _684035;
float* _684031;
_684031 = _453093_681168 + _684030;
float* _684019;
_684019 = _453093_681168 + _684018;
float* _684025;
_684025 = _453093_681168 + _684024;
float* _684101;
_684101 = _453093_681168 + _684100;
float* _684096;
_684096 = _453093_681168 + _684095;
float* _684091;
_684091 = _453093_681168 + _684090;
float* _684079;
_684079 = _453093_681168 + _684078;
float* _684085;
_684085 = _453093_681168 + _684084;
float* _684071;
_684071 = _453093_681168 + _684070;
float* _684066;
_684066 = _453093_681168 + _684065;
float* _684061;
_684061 = _453093_681168 + _684060;
float* _684049;
_684049 = _453093_681168 + _684048;
float* _684055;
_684055 = _453093_681168 + _684054;
float* _685313;
_685313 = _453093_681168 + _685312;
float* _685308;
_685308 = _453093_681168 + _685307;
float* _685303;
_685303 = _453093_681168 + _685302;
float* _685253;
_685253 = _453093_681168 + _685252;
float* _685248;
_685248 = _453093_681168 + _685247;
float* _685243;
_685243 = _453093_681168 + _685242;
float* _685193;
_685193 = _453093_681168 + _685192;
float* _685188;
_685188 = _453093_681168 + _685187;
float* _685183;
_685183 = _453093_681168 + _685182;
float* _684343;
_684343 = _453093_681168 + _684342;
float* _684338;
_684338 = _453093_681168 + _684337;
float* _684333;
_684333 = _453093_681168 + _684332;
float* _684321;
_684321 = _453093_681168 + _684320;
float* _684327;
_684327 = _453093_681168 + _684326;
float* _684403;
_684403 = _453093_681168 + _684402;
float* _684398;
_684398 = _453093_681168 + _684397;
float* _684393;
_684393 = _453093_681168 + _684392;
float* _684381;
_684381 = _453093_681168 + _684380;
float* _684387;
_684387 = _453093_681168 + _684386;
float* _682773;
_682773 = _453093_681168 + _682772;
float* _682768;
_682768 = _453093_681168 + _682767;
float* _682763;
_682763 = _453093_681168 + _682762;
float* _682751;
_682751 = _453093_681168 + _682750;
float* _682757;
_682757 = _453093_681168 + _682756;
float* _682893;
_682893 = _453093_681168 + _682892;
float* _682888;
_682888 = _453093_681168 + _682887;
float* _682883;
_682883 = _453093_681168 + _682882;
float* _682871;
_682871 = _453093_681168 + _682870;
float* _682877;
_682877 = _453093_681168 + _682876;
float* _687307;
_687307 = _453093_681168 + _687306;
float* _687302;
_687302 = _453093_681168 + _687301;
float* _687297;
_687297 = _453093_681168 + _687296;
float* _687397;
_687397 = _453093_681168 + _687396;
float* _687392;
_687392 = _453093_681168 + _687391;
float* _687387;
_687387 = _453093_681168 + _687386;
float* _687427;
_687427 = _453093_681168 + _687426;
float* _687422;
_687422 = _453093_681168 + _687421;
float* _687417;
_687417 = _453093_681168 + _687416;
float* _682410;
_682410 = _453093_681168 + _682409;
float* _682405;
_682405 = _453093_681168 + _682404;
float* _682400;
_682400 = _453093_681168 + _682399;
float* _682388;
_682388 = _453093_681168 + _682387;
float* _682394;
_682394 = _453093_681168 + _682393;
float* _682320;
_682320 = _453093_681168 + _682319;
float* _682315;
_682315 = _453093_681168 + _682314;
float* _682310;
_682310 = _453093_681168 + _682309;
float* _682298;
_682298 = _453093_681168 + _682297;
float* _682304;
_682304 = _453093_681168 + _682303;
float* _685344;
_685344 = _453093_681168 + _685343;
float* _685339;
_685339 = _453093_681168 + _685338;
float* _685334;
_685334 = _453093_681168 + _685333;
float* _685404;
_685404 = _453093_681168 + _685403;
float* _685399;
_685399 = _453093_681168 + _685398;
float* _685394;
_685394 = _453093_681168 + _685393;
float* _685434;
_685434 = _453093_681168 + _685433;
float* _685429;
_685429 = _453093_681168 + _685428;
float* _685424;
_685424 = _453093_681168 + _685423;
float* _685374;
_685374 = _453093_681168 + _685373;
float* _685369;
_685369 = _453093_681168 + _685368;
float* _685364;
_685364 = _453093_681168 + _685363;
float* _685464;
_685464 = _453093_681168 + _685463;
float* _685459;
_685459 = _453093_681168 + _685458;
float* _685454;
_685454 = _453093_681168 + _685453;
float* _682229;
_682229 = _453093_681168 + _682228;
float* _682224;
_682224 = _453093_681168 + _682223;
float* _682219;
_682219 = _453093_681168 + _682218;
float* _682207;
_682207 = _453093_681168 + _682206;
float* _682213;
_682213 = _453093_681168 + _682212;
float* _682289;
_682289 = _453093_681168 + _682288;
float* _682284;
_682284 = _453093_681168 + _682283;
float* _682279;
_682279 = _453093_681168 + _682278;
float* _682267;
_682267 = _453093_681168 + _682266;
float* _682273;
_682273 = _453093_681168 + _682272;
float* _682259;
_682259 = _453093_681168 + _682258;
float* _682254;
_682254 = _453093_681168 + _682253;
float* _682249;
_682249 = _453093_681168 + _682248;
float* _682237;
_682237 = _453093_681168 + _682236;
float* _682243;
_682243 = _453093_681168 + _682242;
float* _682199;
_682199 = _453093_681168 + _682198;
float* _682194;
_682194 = _453093_681168 + _682193;
float* _682189;
_682189 = _453093_681168 + _682188;
float* _682177;
_682177 = _453093_681168 + _682176;
float* _682183;
_682183 = _453093_681168 + _682182;
float* _682169;
_682169 = _453093_681168 + _682168;
float* _682164;
_682164 = _453093_681168 + _682163;
float* _682159;
_682159 = _453093_681168 + _682158;
float* _682147;
_682147 = _453093_681168 + _682146;
float* _682153;
_682153 = _453093_681168 + _682152;
float* _683014;
_683014 = _453093_681168 + _683013;
float* _683009;
_683009 = _453093_681168 + _683008;
float* _683004;
_683004 = _453093_681168 + _683003;
float* _682992;
_682992 = _453093_681168 + _682991;
float* _682998;
_682998 = _453093_681168 + _682997;
float* _682954;
_682954 = _453093_681168 + _682953;
float* _682949;
_682949 = _453093_681168 + _682948;
float* _682944;
_682944 = _453093_681168 + _682943;
float* _682932;
_682932 = _453093_681168 + _682931;
float* _682938;
_682938 = _453093_681168 + _682937;
float* _682924;
_682924 = _453093_681168 + _682923;
float* _682919;
_682919 = _453093_681168 + _682918;
float* _682914;
_682914 = _453093_681168 + _682913;
float* _682902;
_682902 = _453093_681168 + _682901;
float* _682908;
_682908 = _453093_681168 + _682907;
float* _682984;
_682984 = _453093_681168 + _682983;
float* _682979;
_682979 = _453093_681168 + _682978;
float* _682974;
_682974 = _453093_681168 + _682973;
float* _682962;
_682962 = _453093_681168 + _682961;
float* _682968;
_682968 = _453093_681168 + _682967;
float* _683044;
_683044 = _453093_681168 + _683043;
float* _683039;
_683039 = _453093_681168 + _683038;
float* _683034;
_683034 = _453093_681168 + _683033;
float* _683022;
_683022 = _453093_681168 + _683021;
float* _683028;
_683028 = _453093_681168 + _683027;
float* _686340;
_686340 = _453093_681168 + _686339;
float* _686335;
_686335 = _453093_681168 + _686334;
float* _686330;
_686330 = _453093_681168 + _686329;
float* _686250;
_686250 = _453093_681168 + _686249;
float* _686245;
_686245 = _453093_681168 + _686244;
float* _686240;
_686240 = _453093_681168 + _686239;
float* _686370;
_686370 = _453093_681168 + _686369;
float* _686365;
_686365 = _453093_681168 + _686364;
float* _686360;
_686360 = _453093_681168 + _686359;
float* _686280;
_686280 = _453093_681168 + _686279;
float* _686275;
_686275 = _453093_681168 + _686274;
float* _686270;
_686270 = _453093_681168 + _686269;
float* _682742;
_682742 = _453093_681168 + _682741;
float* _682737;
_682737 = _453093_681168 + _682736;
float* _682732;
_682732 = _453093_681168 + _682731;
float* _682720;
_682720 = _453093_681168 + _682719;
float* _682726;
_682726 = _453093_681168 + _682725;
float* _682622;
_682622 = _453093_681168 + _682621;
float* _682617;
_682617 = _453093_681168 + _682616;
float* _682612;
_682612 = _453093_681168 + _682611;
float* _682600;
_682600 = _453093_681168 + _682599;
float* _682606;
_682606 = _453093_681168 + _682605;
float* _682712;
_682712 = _453093_681168 + _682711;
float* _682707;
_682707 = _453093_681168 + _682706;
float* _682702;
_682702 = _453093_681168 + _682701;
float* _682690;
_682690 = _453093_681168 + _682689;
float* _682696;
_682696 = _453093_681168 + _682695;
float* _682652;
_682652 = _453093_681168 + _682651;
float* _682647;
_682647 = _453093_681168 + _682646;
float* _682642;
_682642 = _453093_681168 + _682641;
float* _682630;
_682630 = _453093_681168 + _682629;
float* _682636;
_682636 = _453093_681168 + _682635;
float* _687850;
_687850 = _453093_681168 + _687849;
float* _687845;
_687845 = _453093_681168 + _687844;
float* _687840;
_687840 = _453093_681168 + _687839;
float* _687880;
_687880 = _453093_681168 + _687879;
float* _687875;
_687875 = _453093_681168 + _687874;
float* _687870;
_687870 = _453093_681168 + _687869;
float* _687820;
_687820 = _453093_681168 + _687819;
float* _687815;
_687815 = _453093_681168 + _687814;
float* _687810;
_687810 = _453093_681168 + _687809;
float* _682108;
_682108 = _453093_681168 + _682107;
float* _682103;
_682103 = _453093_681168 + _682102;
float* _682098;
_682098 = _453093_681168 + _682097;
float* _682086;
_682086 = _453093_681168 + _682085;
float* _682092;
_682092 = _453093_681168 + _682091;
float* _682048;
_682048 = _453093_681168 + _682047;
float* _682043;
_682043 = _453093_681168 + _682042;
float* _682038;
_682038 = _453093_681168 + _682037;
float* _682026;
_682026 = _453093_681168 + _682025;
float* _682032;
_682032 = _453093_681168 + _682031;
float* _682018;
_682018 = _453093_681168 + _682017;
float* _682012;
_682012 = _453093_681168 + _682011;
float* _682007;
_682007 = _453093_681168 + _682006;
float* _681994;
_681994 = _453093_681168 + _681993;
float* _682001;
_682001 = _453093_681168 + _682000;
float* _686038;
_686038 = _453093_681168 + _686037;
float* _686033;
_686033 = _453093_681168 + _686032;
float* _686028;
_686028 = _453093_681168 + _686027;
float* _685948;
_685948 = _453093_681168 + _685947;
float* _685943;
_685943 = _453093_681168 + _685942;
float* _685938;
_685938 = _453093_681168 + _685937;
float* _686068;
_686068 = _453093_681168 + _686067;
float* _686063;
_686063 = _453093_681168 + _686062;
float* _686058;
_686058 = _453093_681168 + _686057;
float* _687971;
_687971 = _453093_681168 + _687970;
float* _687966;
_687966 = _453093_681168 + _687965;
float* _687961;
_687961 = _453093_681168 + _687960;
float* _688001;
_688001 = _453093_681168 + _688000;
float* _687996;
_687996 = _453093_681168 + _687995;
float* _687991;
_687991 = _453093_681168 + _687990;
float* _687941;
_687941 = _453093_681168 + _687940;
float* _687936;
_687936 = _453093_681168 + _687935;
float* _687931;
_687931 = _453093_681168 + _687930;
float* _687911;
_687911 = _453093_681168 + _687910;
float* _687906;
_687906 = _453093_681168 + _687905;
float* _687901;
_687901 = _453093_681168 + _687900;
float* _684434;
_684434 = _453093_681168 + _684433;
float* _684429;
_684429 = _453093_681168 + _684428;
float* _684424;
_684424 = _453093_681168 + _684423;
float* _684412;
_684412 = _453093_681168 + _684411;
float* _684418;
_684418 = _453093_681168 + _684417;
float* _684494;
_684494 = _453093_681168 + _684493;
float* _684489;
_684489 = _453093_681168 + _684488;
float* _684484;
_684484 = _453093_681168 + _684483;
float* _684472;
_684472 = _453093_681168 + _684471;
float* _684478;
_684478 = _453093_681168 + _684477;
float* _684554;
_684554 = _453093_681168 + _684553;
float* _684549;
_684549 = _453093_681168 + _684548;
float* _684544;
_684544 = _453093_681168 + _684543;
float* _684532;
_684532 = _453093_681168 + _684531;
float* _684538;
_684538 = _453093_681168 + _684537;
float* _683105;
_683105 = _453093_681168 + _683104;
float* _683100;
_683100 = _453093_681168 + _683099;
float* _683095;
_683095 = _453093_681168 + _683094;
float* _683083;
_683083 = _453093_681168 + _683082;
float* _683089;
_683089 = _453093_681168 + _683088;
float* _683075;
_683075 = _453093_681168 + _683074;
float* _683070;
_683070 = _453093_681168 + _683069;
float* _683065;
_683065 = _453093_681168 + _683064;
float* _683053;
_683053 = _453093_681168 + _683052;
float* _683059;
_683059 = _453093_681168 + _683058;
float* _683195;
_683195 = _453093_681168 + _683194;
float* _683190;
_683190 = _453093_681168 + _683189;
float* _683185;
_683185 = _453093_681168 + _683184;
float* _683173;
_683173 = _453093_681168 + _683172;
float* _683179;
_683179 = _453093_681168 + _683178;
float* _687669;
_687669 = _453093_681168 + _687668;
float* _687664;
_687664 = _453093_681168 + _687663;
float* _687659;
_687659 = _453093_681168 + _687658;
float* _687639;
_687639 = _453093_681168 + _687638;
float* _687634;
_687634 = _453093_681168 + _687633;
float* _687629;
_687629 = _453093_681168 + _687628;
float* _687699;
_687699 = _453093_681168 + _687698;
float* _687694;
_687694 = _453093_681168 + _687693;
float* _687689;
_687689 = _453093_681168 + _687688;
float* _687609;
_687609 = _453093_681168 + _687608;
float* _687604;
_687604 = _453093_681168 + _687603;
float* _687599;
_687599 = _453093_681168 + _687598;
float* _687729;
_687729 = _453093_681168 + _687728;
float* _687724;
_687724 = _453093_681168 + _687723;
float* _687719;
_687719 = _453093_681168 + _687718;
float* _685917;
_685917 = _453093_681168 + _685916;
float* _685912;
_685912 = _453093_681168 + _685911;
float* _685907;
_685907 = _453093_681168 + _685906;
float* _685797;
_685797 = _453093_681168 + _685796;
float* _685792;
_685792 = _453093_681168 + _685791;
float* _685787;
_685787 = _453093_681168 + _685786;
float* _685887;
_685887 = _453093_681168 + _685886;
float* _685882;
_685882 = _453093_681168 + _685881;
float* _685877;
_685877 = _453093_681168 + _685876;
float* _685827;
_685827 = _453093_681168 + _685826;
float* _685822;
_685822 = _453093_681168 + _685821;
float* _685817;
_685817 = _453093_681168 + _685816;
float* _685102;
_685102 = _453093_681168 + _685101;
float* _685097;
_685097 = _453093_681168 + _685096;
float* _685092;
_685092 = _453093_681168 + _685091;
float* _685162;
_685162 = _453093_681168 + _685161;
float* _685157;
_685157 = _453093_681168 + _685156;
float* _685152;
_685152 = _453093_681168 + _685151;
float* _685132;
_685132 = _453093_681168 + _685131;
float* _685127;
_685127 = _453093_681168 + _685126;
float* _685122;
_685122 = _453093_681168 + _685121;
float* _685042;
_685042 = _453093_681168 + _685041;
float* _685036;
_685036 = _453093_681168 + _685035;
float* _685031;
_685031 = _453093_681168 + _685030;
float* _685072;
_685072 = _453093_681168 + _685071;
float* _685067;
_685067 = _453093_681168 + _685066;
float* _685062;
_685062 = _453093_681168 + _685061;
float* _683407;
_683407 = _453093_681168 + _683406;
float* _683402;
_683402 = _453093_681168 + _683401;
float* _683397;
_683397 = _453093_681168 + _683396;
float* _683385;
_683385 = _453093_681168 + _683384;
float* _683391;
_683391 = _453093_681168 + _683390;
float* _683497;
_683497 = _453093_681168 + _683496;
float* _683492;
_683492 = _453093_681168 + _683491;
float* _683487;
_683487 = _453093_681168 + _683486;
float* _683475;
_683475 = _453093_681168 + _683474;
float* _683481;
_683481 = _453093_681168 + _683480;
float* _683467;
_683467 = _453093_681168 + _683466;
float* _683462;
_683462 = _453093_681168 + _683461;
float* _683457;
_683457 = _453093_681168 + _683456;
float* _683445;
_683445 = _453093_681168 + _683444;
float* _683451;
_683451 = _453093_681168 + _683450;
float* _683377;
_683377 = _453093_681168 + _683376;
float* _683372;
_683372 = _453093_681168 + _683371;
float* _683367;
_683367 = _453093_681168 + _683366;
float* _683355;
_683355 = _453093_681168 + _683354;
float* _683361;
_683361 = _453093_681168 + _683360;
float* _686189;
_686189 = _453093_681168 + _686188;
float* _686184;
_686184 = _453093_681168 + _686183;
float* _686179;
_686179 = _453093_681168 + _686178;
float* _686129;
_686129 = _453093_681168 + _686128;
float* _686124;
_686124 = _453093_681168 + _686123;
float* _686119;
_686119 = _453093_681168 + _686118;
float* _686099;
_686099 = _453093_681168 + _686098;
float* _686094;
_686094 = _453093_681168 + _686093;
float* _686089;
_686089 = _453093_681168 + _686088;
float* _686219;
_686219 = _453093_681168 + _686218;
float* _686214;
_686214 = _453093_681168 + _686213;
float* _686209;
_686209 = _453093_681168 + _686208;
float* _686159;
_686159 = _453093_681168 + _686158;
float* _686154;
_686154 = _453093_681168 + _686153;
float* _686149;
_686149 = _453093_681168 + _686148;
float* _684222;
_684222 = _453093_681168 + _684221;
float* _684217;
_684217 = _453093_681168 + _684216;
float* _684212;
_684212 = _453093_681168 + _684211;
float* _684200;
_684200 = _453093_681168 + _684199;
float* _684206;
_684206 = _453093_681168 + _684205;
float* _684252;
_684252 = _453093_681168 + _684251;
float* _684247;
_684247 = _453093_681168 + _684246;
float* _684242;
_684242 = _453093_681168 + _684241;
float* _684230;
_684230 = _453093_681168 + _684229;
float* _684236;
_684236 = _453093_681168 + _684235;
float* _684132;
_684132 = _453093_681168 + _684131;
float* _684127;
_684127 = _453093_681168 + _684126;
float* _684122;
_684122 = _453093_681168 + _684121;
float* _684110;
_684110 = _453093_681168 + _684109;
float* _684116;
_684116 = _453093_681168 + _684115;
float* _684192;
_684192 = _453093_681168 + _684191;
float* _684187;
_684187 = _453093_681168 + _684186;
float* _684182;
_684182 = _453093_681168 + _684181;
float* _684170;
_684170 = _453093_681168 + _684169;
float* _684176;
_684176 = _453093_681168 + _684175;
float* _684162;
_684162 = _453093_681168 + _684161;
float* _684157;
_684157 = _453093_681168 + _684156;
float* _684152;
_684152 = _453093_681168 + _684151;
float* _684140;
_684140 = _453093_681168 + _684139;
float* _684146;
_684146 = _453093_681168 + _684145;
float _681995;
_681995 = *_681994;
float _682002;
_682002 = *_682001;
float _682008;
_682008 = *_682007;
float _682013;
_682013 = *_682012;
float _682019;
_682019 = *_682018;
float _682027;
_682027 = *_682026;
float _682033;
_682033 = *_682032;
float _682039;
_682039 = *_682038;
float _682044;
_682044 = *_682043;
float _682049;
_682049 = *_682048;
float _682057;
_682057 = *_682056;
float _682063;
_682063 = *_682062;
float _682069;
_682069 = *_682068;
float _682074;
_682074 = *_682073;
float _682079;
_682079 = *_682078;
float _682087;
_682087 = *_682086;
float _682093;
_682093 = *_682092;
float _682099;
_682099 = *_682098;
float _682104;
_682104 = *_682103;
float _682109;
_682109 = *_682108;
float _682117;
_682117 = *_682116;
float _682123;
_682123 = *_682122;
float _682129;
_682129 = *_682128;
float _682134;
_682134 = *_682133;
float _682139;
_682139 = *_682138;
float _682148;
_682148 = *_682147;
float _682154;
_682154 = *_682153;
float _682160;
_682160 = *_682159;
float _682165;
_682165 = *_682164;
float _682170;
_682170 = *_682169;
float _682178;
_682178 = *_682177;
float _682184;
_682184 = *_682183;
float _682190;
_682190 = *_682189;
float _682195;
_682195 = *_682194;
float _682200;
_682200 = *_682199;
float _682208;
_682208 = *_682207;
float _682214;
_682214 = *_682213;
float _682220;
_682220 = *_682219;
float _682225;
_682225 = *_682224;
float _682230;
_682230 = *_682229;
float _682238;
_682238 = *_682237;
float _682244;
_682244 = *_682243;
float _682250;
_682250 = *_682249;
float _682255;
_682255 = *_682254;
float _682260;
_682260 = *_682259;
float _682268;
_682268 = *_682267;
float _682274;
_682274 = *_682273;
float _682280;
_682280 = *_682279;
float _682285;
_682285 = *_682284;
float _682290;
_682290 = *_682289;
float _682299;
_682299 = *_682298;
float _682305;
_682305 = *_682304;
float _682311;
_682311 = *_682310;
float _682316;
_682316 = *_682315;
float _682321;
_682321 = *_682320;
float _682329;
_682329 = *_682328;
float _682335;
_682335 = *_682334;
float _682341;
_682341 = *_682340;
float _682346;
_682346 = *_682345;
float _682351;
_682351 = *_682350;
float _682359;
_682359 = *_682358;
float _682365;
_682365 = *_682364;
float _682371;
_682371 = *_682370;
float _682376;
_682376 = *_682375;
float _682381;
_682381 = *_682380;
float _682389;
_682389 = *_682388;
float _682395;
_682395 = *_682394;
float _682401;
_682401 = *_682400;
float _682406;
_682406 = *_682405;
float _682411;
_682411 = *_682410;
float _682419;
_682419 = *_682418;
float _682425;
_682425 = *_682424;
float _682431;
_682431 = *_682430;
float _682436;
_682436 = *_682435;
float _682441;
_682441 = *_682440;
float _682450;
_682450 = *_682449;
float _682456;
_682456 = *_682455;
float _682462;
_682462 = *_682461;
float _682467;
_682467 = *_682466;
float _682472;
_682472 = *_682471;
float _682480;
_682480 = *_682479;
float _682486;
_682486 = *_682485;
float _682492;
_682492 = *_682491;
float _682497;
_682497 = *_682496;
float _682502;
_682502 = *_682501;
float _682510;
_682510 = *_682509;
float _682516;
_682516 = *_682515;
float _682522;
_682522 = *_682521;
float _682527;
_682527 = *_682526;
float _682532;
_682532 = *_682531;
float _682540;
_682540 = *_682539;
float _682546;
_682546 = *_682545;
float _682552;
_682552 = *_682551;
float _682557;
_682557 = *_682556;
float _682562;
_682562 = *_682561;
float _682570;
_682570 = *_682569;
float _682576;
_682576 = *_682575;
float _682582;
_682582 = *_682581;
float _682587;
_682587 = *_682586;
float _682592;
_682592 = *_682591;
float _682601;
_682601 = *_682600;
float _682607;
_682607 = *_682606;
float _682613;
_682613 = *_682612;
float _682618;
_682618 = *_682617;
float _682623;
_682623 = *_682622;
float _682631;
_682631 = *_682630;
float _682637;
_682637 = *_682636;
float _682643;
_682643 = *_682642;
float _682648;
_682648 = *_682647;
float _682653;
_682653 = *_682652;
float _682661;
_682661 = *_682660;
float _682667;
_682667 = *_682666;
float _682673;
_682673 = *_682672;
float _682678;
_682678 = *_682677;
float _682683;
_682683 = *_682682;
float _682691;
_682691 = *_682690;
float _682697;
_682697 = *_682696;
float _682703;
_682703 = *_682702;
float _682708;
_682708 = *_682707;
float _682713;
_682713 = *_682712;
float _682721;
_682721 = *_682720;
float _682727;
_682727 = *_682726;
float _682733;
_682733 = *_682732;
float _682738;
_682738 = *_682737;
float _682743;
_682743 = *_682742;
float _682752;
_682752 = *_682751;
float _682758;
_682758 = *_682757;
float _682764;
_682764 = *_682763;
float _682769;
_682769 = *_682768;
float _682774;
_682774 = *_682773;
float _682782;
_682782 = *_682781;
float _682788;
_682788 = *_682787;
float _682794;
_682794 = *_682793;
float _682799;
_682799 = *_682798;
float _682804;
_682804 = *_682803;
float _682812;
_682812 = *_682811;
float _682818;
_682818 = *_682817;
float _682824;
_682824 = *_682823;
float _682829;
_682829 = *_682828;
float _682834;
_682834 = *_682833;
float _682842;
_682842 = *_682841;
float _682848;
_682848 = *_682847;
float _682854;
_682854 = *_682853;
float _682859;
_682859 = *_682858;
float _682864;
_682864 = *_682863;
float _682872;
_682872 = *_682871;
float _682878;
_682878 = *_682877;
float _682884;
_682884 = *_682883;
float _682889;
_682889 = *_682888;
float _682894;
_682894 = *_682893;
float _682903;
_682903 = *_682902;
float _682909;
_682909 = *_682908;
float _682915;
_682915 = *_682914;
float _682920;
_682920 = *_682919;
float _682925;
_682925 = *_682924;
float _682933;
_682933 = *_682932;
float _682939;
_682939 = *_682938;
float _682945;
_682945 = *_682944;
float _682950;
_682950 = *_682949;
float _682955;
_682955 = *_682954;
float _682963;
_682963 = *_682962;
float _682969;
_682969 = *_682968;
float _682975;
_682975 = *_682974;
float _682980;
_682980 = *_682979;
float _682985;
_682985 = *_682984;
float _682993;
_682993 = *_682992;
float _682999;
_682999 = *_682998;
float _683005;
_683005 = *_683004;
float _683010;
_683010 = *_683009;
float _683015;
_683015 = *_683014;
float _683023;
_683023 = *_683022;
float _683029;
_683029 = *_683028;
float _683035;
_683035 = *_683034;
float _683040;
_683040 = *_683039;
float _683045;
_683045 = *_683044;
float _683054;
_683054 = *_683053;
float _683060;
_683060 = *_683059;
float _683066;
_683066 = *_683065;
float _683071;
_683071 = *_683070;
float _683076;
_683076 = *_683075;
float _683084;
_683084 = *_683083;
float _683090;
_683090 = *_683089;
float _683096;
_683096 = *_683095;
float _683101;
_683101 = *_683100;
float _683106;
_683106 = *_683105;
float _683114;
_683114 = *_683113;
float _683120;
_683120 = *_683119;
float _683126;
_683126 = *_683125;
float _683131;
_683131 = *_683130;
float _683136;
_683136 = *_683135;
float _683144;
_683144 = *_683143;
float _683150;
_683150 = *_683149;
float _683156;
_683156 = *_683155;
float _683161;
_683161 = *_683160;
float _683166;
_683166 = *_683165;
float _683174;
_683174 = *_683173;
float _683180;
_683180 = *_683179;
float _683186;
_683186 = *_683185;
float _683191;
_683191 = *_683190;
float _683196;
_683196 = *_683195;
float _683205;
_683205 = *_683204;
float _683211;
_683211 = *_683210;
float _683217;
_683217 = *_683216;
float _683222;
_683222 = *_683221;
float _683227;
_683227 = *_683226;
float _683235;
_683235 = *_683234;
float _683241;
_683241 = *_683240;
float _683247;
_683247 = *_683246;
float _683252;
_683252 = *_683251;
float _683257;
_683257 = *_683256;
float _683265;
_683265 = *_683264;
float _683271;
_683271 = *_683270;
float _683277;
_683277 = *_683276;
float _683282;
_683282 = *_683281;
float _683287;
_683287 = *_683286;
float _683295;
_683295 = *_683294;
float _683301;
_683301 = *_683300;
float _683307;
_683307 = *_683306;
float _683312;
_683312 = *_683311;
float _683317;
_683317 = *_683316;
float _683325;
_683325 = *_683324;
float _683331;
_683331 = *_683330;
float _683337;
_683337 = *_683336;
float _683342;
_683342 = *_683341;
float _683347;
_683347 = *_683346;
float _683356;
_683356 = *_683355;
float _683362;
_683362 = *_683361;
float _683368;
_683368 = *_683367;
float _683373;
_683373 = *_683372;
float _683378;
_683378 = *_683377;
float _683386;
_683386 = *_683385;
float _683392;
_683392 = *_683391;
float _683398;
_683398 = *_683397;
float _683403;
_683403 = *_683402;
float _683408;
_683408 = *_683407;
float _683416;
_683416 = *_683415;
float _683422;
_683422 = *_683421;
float _683428;
_683428 = *_683427;
float _683433;
_683433 = *_683432;
float _683438;
_683438 = *_683437;
float _683446;
_683446 = *_683445;
float _683452;
_683452 = *_683451;
float _683458;
_683458 = *_683457;
float _683463;
_683463 = *_683462;
float _683468;
_683468 = *_683467;
float _683476;
_683476 = *_683475;
float _683482;
_683482 = *_683481;
float _683488;
_683488 = *_683487;
float _683493;
_683493 = *_683492;
float _683498;
_683498 = *_683497;
float _683507;
_683507 = *_683506;
float _683513;
_683513 = *_683512;
float _683519;
_683519 = *_683518;
float _683524;
_683524 = *_683523;
float _683529;
_683529 = *_683528;
float _683537;
_683537 = *_683536;
float _683543;
_683543 = *_683542;
float _683549;
_683549 = *_683548;
float _683554;
_683554 = *_683553;
float _683559;
_683559 = *_683558;
float _683567;
_683567 = *_683566;
float _683573;
_683573 = *_683572;
float _683579;
_683579 = *_683578;
float _683584;
_683584 = *_683583;
float _683589;
_683589 = *_683588;
float _683597;
_683597 = *_683596;
float _683603;
_683603 = *_683602;
float _683609;
_683609 = *_683608;
float _683614;
_683614 = *_683613;
float _683619;
_683619 = *_683618;
float _683627;
_683627 = *_683626;
float _683633;
_683633 = *_683632;
float _683639;
_683639 = *_683638;
float _683644;
_683644 = *_683643;
float _683649;
_683649 = *_683648;
float _683658;
_683658 = *_683657;
float _683664;
_683664 = *_683663;
float _683670;
_683670 = *_683669;
float _683675;
_683675 = *_683674;
float _683680;
_683680 = *_683679;
float _683688;
_683688 = *_683687;
float _683694;
_683694 = *_683693;
float _683700;
_683700 = *_683699;
float _683705;
_683705 = *_683704;
float _683710;
_683710 = *_683709;
float _683718;
_683718 = *_683717;
float _683724;
_683724 = *_683723;
float _683730;
_683730 = *_683729;
float _683735;
_683735 = *_683734;
float _683740;
_683740 = *_683739;
float _683748;
_683748 = *_683747;
float _683754;
_683754 = *_683753;
float _683760;
_683760 = *_683759;
float _683765;
_683765 = *_683764;
float _683770;
_683770 = *_683769;
float _683778;
_683778 = *_683777;
float _683784;
_683784 = *_683783;
float _683790;
_683790 = *_683789;
float _683795;
_683795 = *_683794;
float _683800;
_683800 = *_683799;
float _683809;
_683809 = *_683808;
float _683815;
_683815 = *_683814;
float _683821;
_683821 = *_683820;
float _683826;
_683826 = *_683825;
float _683831;
_683831 = *_683830;
float _683839;
_683839 = *_683838;
float _683845;
_683845 = *_683844;
float _683851;
_683851 = *_683850;
float _683856;
_683856 = *_683855;
float _683861;
_683861 = *_683860;
float _683869;
_683869 = *_683868;
float _683875;
_683875 = *_683874;
float _683881;
_683881 = *_683880;
float _683886;
_683886 = *_683885;
float _683891;
_683891 = *_683890;
float _683899;
_683899 = *_683898;
float _683905;
_683905 = *_683904;
float _683911;
_683911 = *_683910;
float _683916;
_683916 = *_683915;
float _683921;
_683921 = *_683920;
float _683929;
_683929 = *_683928;
float _683935;
_683935 = *_683934;
float _683941;
_683941 = *_683940;
float _683946;
_683946 = *_683945;
float _683951;
_683951 = *_683950;
float _683960;
_683960 = *_683959;
float _683966;
_683966 = *_683965;
float _683972;
_683972 = *_683971;
float _683977;
_683977 = *_683976;
float _683982;
_683982 = *_683981;
float _683990;
_683990 = *_683989;
float _683996;
_683996 = *_683995;
float _684002;
_684002 = *_684001;
float _684007;
_684007 = *_684006;
float _684012;
_684012 = *_684011;
float _684020;
_684020 = *_684019;
float _684026;
_684026 = *_684025;
float _684032;
_684032 = *_684031;
float _684037;
_684037 = *_684036;
float _684042;
_684042 = *_684041;
float _684050;
_684050 = *_684049;
float _684056;
_684056 = *_684055;
float _684062;
_684062 = *_684061;
float _684067;
_684067 = *_684066;
float _684072;
_684072 = *_684071;
float _684080;
_684080 = *_684079;
float _684086;
_684086 = *_684085;
float _684092;
_684092 = *_684091;
float _684097;
_684097 = *_684096;
float _684102;
_684102 = *_684101;
float _684111;
_684111 = *_684110;
float _684117;
_684117 = *_684116;
float _684123;
_684123 = *_684122;
float _684128;
_684128 = *_684127;
float _684133;
_684133 = *_684132;
float _684141;
_684141 = *_684140;
float _684147;
_684147 = *_684146;
float _684153;
_684153 = *_684152;
float _684158;
_684158 = *_684157;
float _684163;
_684163 = *_684162;
float _684171;
_684171 = *_684170;
float _684177;
_684177 = *_684176;
float _684183;
_684183 = *_684182;
float _684188;
_684188 = *_684187;
float _684193;
_684193 = *_684192;
float _684201;
_684201 = *_684200;
float _684207;
_684207 = *_684206;
float _684213;
_684213 = *_684212;
float _684218;
_684218 = *_684217;
float _684223;
_684223 = *_684222;
float _684231;
_684231 = *_684230;
float _684237;
_684237 = *_684236;
float _684243;
_684243 = *_684242;
float _684248;
_684248 = *_684247;
float _684253;
_684253 = *_684252;
float _684262;
_684262 = *_684261;
float _684268;
_684268 = *_684267;
float _684274;
_684274 = *_684273;
float _684279;
_684279 = *_684278;
float _684284;
_684284 = *_684283;
float _684292;
_684292 = *_684291;
float _684298;
_684298 = *_684297;
float _684304;
_684304 = *_684303;
float _684309;
_684309 = *_684308;
float _684314;
_684314 = *_684313;
float _684322;
_684322 = *_684321;
float _684328;
_684328 = *_684327;
float _684334;
_684334 = *_684333;
float _684339;
_684339 = *_684338;
float _684344;
_684344 = *_684343;
float _684352;
_684352 = *_684351;
float _684358;
_684358 = *_684357;
float _684364;
_684364 = *_684363;
float _684369;
_684369 = *_684368;
float _684374;
_684374 = *_684373;
float _684382;
_684382 = *_684381;
float _684388;
_684388 = *_684387;
float _684394;
_684394 = *_684393;
float _684399;
_684399 = *_684398;
float _684404;
_684404 = *_684403;
float _684413;
_684413 = *_684412;
float _684419;
_684419 = *_684418;
float _684425;
_684425 = *_684424;
float _684430;
_684430 = *_684429;
float _684435;
_684435 = *_684434;
float _684443;
_684443 = *_684442;
float _684449;
_684449 = *_684448;
float _684455;
_684455 = *_684454;
float _684460;
_684460 = *_684459;
float _684465;
_684465 = *_684464;
float _684473;
_684473 = *_684472;
float _684479;
_684479 = *_684478;
float _684485;
_684485 = *_684484;
float _684490;
_684490 = *_684489;
float _684495;
_684495 = *_684494;
float _684503;
_684503 = *_684502;
float _684509;
_684509 = *_684508;
float _684515;
_684515 = *_684514;
float _684520;
_684520 = *_684519;
float _684525;
_684525 = *_684524;
float _684533;
_684533 = *_684532;
float _684539;
_684539 = *_684538;
float _684545;
_684545 = *_684544;
float _684550;
_684550 = *_684549;
float _684555;
_684555 = *_684554;
float _684564;
_684564 = *_684563;
float _684570;
_684570 = *_684569;
float _684576;
_684576 = *_684575;
float _684581;
_684581 = *_684580;
float _684586;
_684586 = *_684585;
float _684594;
_684594 = *_684593;
float _684600;
_684600 = *_684599;
float _684606;
_684606 = *_684605;
float _684611;
_684611 = *_684610;
float _684616;
_684616 = *_684615;
float _684624;
_684624 = *_684623;
float _684630;
_684630 = *_684629;
float _684636;
_684636 = *_684635;
float _684641;
_684641 = *_684640;
float _684646;
_684646 = *_684645;
float _684654;
_684654 = *_684653;
float _684660;
_684660 = *_684659;
float _684666;
_684666 = *_684665;
float _684671;
_684671 = *_684670;
float _684676;
_684676 = *_684675;
float _684684;
_684684 = *_684683;
float _684690;
_684690 = *_684689;
float _684696;
_684696 = *_684695;
float _684701;
_684701 = *_684700;
float _684706;
_684706 = *_684705;
float _684715;
_684715 = *_684714;
float _684721;
_684721 = *_684720;
float _684727;
_684727 = *_684726;
float _684732;
_684732 = *_684731;
float _684737;
_684737 = *_684736;
float _684745;
_684745 = *_684744;
float _684751;
_684751 = *_684750;
float _684757;
_684757 = *_684756;
float _684762;
_684762 = *_684761;
float _684767;
_684767 = *_684766;
float _684775;
_684775 = *_684774;
float _684781;
_684781 = *_684780;
float _684787;
_684787 = *_684786;
float _684792;
_684792 = *_684791;
float _684797;
_684797 = *_684796;
float _684805;
_684805 = *_684804;
float _684811;
_684811 = *_684810;
float _684817;
_684817 = *_684816;
float _684822;
_684822 = *_684821;
float _684827;
_684827 = *_684826;
float _684835;
_684835 = *_684834;
float _684841;
_684841 = *_684840;
float _684847;
_684847 = *_684846;
float _684852;
_684852 = *_684851;
float _684857;
_684857 = *_684856;
float _684866;
_684866 = *_684865;
float _684872;
_684872 = *_684871;
float _684878;
_684878 = *_684877;
float _684883;
_684883 = *_684882;
float _684888;
_684888 = *_684887;
float _684896;
_684896 = *_684895;
float _684902;
_684902 = *_684901;
float _684908;
_684908 = *_684907;
float _684913;
_684913 = *_684912;
float _684918;
_684918 = *_684917;
float _684926;
_684926 = *_684925;
float _684932;
_684932 = *_684931;
float _684938;
_684938 = *_684937;
float _684943;
_684943 = *_684942;
float _684948;
_684948 = *_684947;
float _684956;
_684956 = *_684955;
float _684962;
_684962 = *_684961;
float _684968;
_684968 = *_684967;
float _684973;
_684973 = *_684972;
float _684978;
_684978 = *_684977;
float _684986;
_684986 = *_684985;
float _684992;
_684992 = *_684991;
float _684998;
_684998 = *_684997;
float _685003;
_685003 = *_685002;
float _685008;
_685008 = *_685007;
float _685019;
_685019 = *_685018;
float _685026;
_685026 = *_685025;
float _685032;
_685032 = *_685031;
float _685037;
_685037 = *_685036;
float _685043;
_685043 = *_685042;
float _685051;
_685051 = *_685050;
float _685057;
_685057 = *_685056;
float _685063;
_685063 = *_685062;
float _685068;
_685068 = *_685067;
float _685073;
_685073 = *_685072;
float _685081;
_685081 = *_685080;
float _685087;
_685087 = *_685086;
float _685093;
_685093 = *_685092;
float _685098;
_685098 = *_685097;
float _685103;
_685103 = *_685102;
float _685111;
_685111 = *_685110;
float _685117;
_685117 = *_685116;
float _685123;
_685123 = *_685122;
float _685128;
_685128 = *_685127;
float _685133;
_685133 = *_685132;
float _685141;
_685141 = *_685140;
float _685147;
_685147 = *_685146;
float _685153;
_685153 = *_685152;
float _685158;
_685158 = *_685157;
float _685163;
_685163 = *_685162;
float _685172;
_685172 = *_685171;
float _685178;
_685178 = *_685177;
float _685184;
_685184 = *_685183;
float _685189;
_685189 = *_685188;
float _685194;
_685194 = *_685193;
float _685202;
_685202 = *_685201;
float _685208;
_685208 = *_685207;
float _685214;
_685214 = *_685213;
float _685219;
_685219 = *_685218;
float _685224;
_685224 = *_685223;
float _685232;
_685232 = *_685231;
float _685238;
_685238 = *_685237;
float _685244;
_685244 = *_685243;
float _685249;
_685249 = *_685248;
float _685254;
_685254 = *_685253;
float _685262;
_685262 = *_685261;
float _685268;
_685268 = *_685267;
float _685274;
_685274 = *_685273;
float _685279;
_685279 = *_685278;
float _685284;
_685284 = *_685283;
float _685292;
_685292 = *_685291;
float _685298;
_685298 = *_685297;
float _685304;
_685304 = *_685303;
float _685309;
_685309 = *_685308;
float _685314;
_685314 = *_685313;
float _685323;
_685323 = *_685322;
float _685329;
_685329 = *_685328;
float _685335;
_685335 = *_685334;
float _685340;
_685340 = *_685339;
float _685345;
_685345 = *_685344;
float _685353;
_685353 = *_685352;
float _685359;
_685359 = *_685358;
float _685365;
_685365 = *_685364;
float _685370;
_685370 = *_685369;
float _685375;
_685375 = *_685374;
float _685383;
_685383 = *_685382;
float _685389;
_685389 = *_685388;
float _685395;
_685395 = *_685394;
float _685400;
_685400 = *_685399;
float _685405;
_685405 = *_685404;
float _685413;
_685413 = *_685412;
float _685419;
_685419 = *_685418;
float _685425;
_685425 = *_685424;
float _685430;
_685430 = *_685429;
float _685435;
_685435 = *_685434;
float _685443;
_685443 = *_685442;
float _685449;
_685449 = *_685448;
float _685455;
_685455 = *_685454;
float _685460;
_685460 = *_685459;
float _685465;
_685465 = *_685464;
float _685474;
_685474 = *_685473;
float _685480;
_685480 = *_685479;
float _685486;
_685486 = *_685485;
float _685491;
_685491 = *_685490;
float _685496;
_685496 = *_685495;
float _685504;
_685504 = *_685503;
float _685510;
_685510 = *_685509;
float _685516;
_685516 = *_685515;
float _685521;
_685521 = *_685520;
float _685526;
_685526 = *_685525;
float _685534;
_685534 = *_685533;
float _685540;
_685540 = *_685539;
float _685546;
_685546 = *_685545;
float _685551;
_685551 = *_685550;
float _685556;
_685556 = *_685555;
float _685564;
_685564 = *_685563;
float _685570;
_685570 = *_685569;
float _685576;
_685576 = *_685575;
float _685581;
_685581 = *_685580;
float _685586;
_685586 = *_685585;
float _685594;
_685594 = *_685593;
float _685600;
_685600 = *_685599;
float _685606;
_685606 = *_685605;
float _685611;
_685611 = *_685610;
float _685616;
_685616 = *_685615;
float _685625;
_685625 = *_685624;
float _685631;
_685631 = *_685630;
float _685637;
_685637 = *_685636;
float _685642;
_685642 = *_685641;
float _685647;
_685647 = *_685646;
float _685655;
_685655 = *_685654;
float _685661;
_685661 = *_685660;
float _685667;
_685667 = *_685666;
float _685672;
_685672 = *_685671;
float _685677;
_685677 = *_685676;
float _685685;
_685685 = *_685684;
float _685691;
_685691 = *_685690;
float _685697;
_685697 = *_685696;
float _685702;
_685702 = *_685701;
float _685707;
_685707 = *_685706;
float _685715;
_685715 = *_685714;
float _685721;
_685721 = *_685720;
float _685727;
_685727 = *_685726;
float _685732;
_685732 = *_685731;
float _685737;
_685737 = *_685736;
float _685745;
_685745 = *_685744;
float _685751;
_685751 = *_685750;
float _685757;
_685757 = *_685756;
float _685762;
_685762 = *_685761;
float _685767;
_685767 = *_685766;
float _685776;
_685776 = *_685775;
float _685782;
_685782 = *_685781;
float _685788;
_685788 = *_685787;
float _685793;
_685793 = *_685792;
float _685798;
_685798 = *_685797;
float _685806;
_685806 = *_685805;
float _685812;
_685812 = *_685811;
float _685818;
_685818 = *_685817;
float _685823;
_685823 = *_685822;
float _685828;
_685828 = *_685827;
float _685836;
_685836 = *_685835;
float _685842;
_685842 = *_685841;
float _685848;
_685848 = *_685847;
float _685853;
_685853 = *_685852;
float _685858;
_685858 = *_685857;
float _685866;
_685866 = *_685865;
float _685872;
_685872 = *_685871;
float _685878;
_685878 = *_685877;
float _685883;
_685883 = *_685882;
float _685888;
_685888 = *_685887;
float _685896;
_685896 = *_685895;
float _685902;
_685902 = *_685901;
float _685908;
_685908 = *_685907;
float _685913;
_685913 = *_685912;
float _685918;
_685918 = *_685917;
float _685927;
_685927 = *_685926;
float _685933;
_685933 = *_685932;
float _685939;
_685939 = *_685938;
float _685944;
_685944 = *_685943;
float _685949;
_685949 = *_685948;
float _685957;
_685957 = *_685956;
float _685963;
_685963 = *_685962;
float _685969;
_685969 = *_685968;
float _685974;
_685974 = *_685973;
float _685979;
_685979 = *_685978;
float _685987;
_685987 = *_685986;
float _685993;
_685993 = *_685992;
float _685999;
_685999 = *_685998;
float _686004;
_686004 = *_686003;
float _686009;
_686009 = *_686008;
float _686017;
_686017 = *_686016;
float _686023;
_686023 = *_686022;
float _686029;
_686029 = *_686028;
float _686034;
_686034 = *_686033;
float _686039;
_686039 = *_686038;
float _686047;
_686047 = *_686046;
float _686053;
_686053 = *_686052;
float _686059;
_686059 = *_686058;
float _686064;
_686064 = *_686063;
float _686069;
_686069 = *_686068;
float _686078;
_686078 = *_686077;
float _686084;
_686084 = *_686083;
float _686090;
_686090 = *_686089;
float _686095;
_686095 = *_686094;
float _686100;
_686100 = *_686099;
float _686108;
_686108 = *_686107;
float _686114;
_686114 = *_686113;
float _686120;
_686120 = *_686119;
float _686125;
_686125 = *_686124;
float _686130;
_686130 = *_686129;
float _686138;
_686138 = *_686137;
float _686144;
_686144 = *_686143;
float _686150;
_686150 = *_686149;
float _686155;
_686155 = *_686154;
float _686160;
_686160 = *_686159;
float _686168;
_686168 = *_686167;
float _686174;
_686174 = *_686173;
float _686180;
_686180 = *_686179;
float _686185;
_686185 = *_686184;
float _686190;
_686190 = *_686189;
float _686198;
_686198 = *_686197;
float _686204;
_686204 = *_686203;
float _686210;
_686210 = *_686209;
float _686215;
_686215 = *_686214;
float _686220;
_686220 = *_686219;
float _686229;
_686229 = *_686228;
float _686235;
_686235 = *_686234;
float _686241;
_686241 = *_686240;
float _686246;
_686246 = *_686245;
float _686251;
_686251 = *_686250;
float _686259;
_686259 = *_686258;
float _686265;
_686265 = *_686264;
float _686271;
_686271 = *_686270;
float _686276;
_686276 = *_686275;
float _686281;
_686281 = *_686280;
float _686289;
_686289 = *_686288;
float _686295;
_686295 = *_686294;
float _686301;
_686301 = *_686300;
float _686306;
_686306 = *_686305;
float _686311;
_686311 = *_686310;
float _686319;
_686319 = *_686318;
float _686325;
_686325 = *_686324;
float _686331;
_686331 = *_686330;
float _686336;
_686336 = *_686335;
float _686341;
_686341 = *_686340;
float _686349;
_686349 = *_686348;
float _686355;
_686355 = *_686354;
float _686361;
_686361 = *_686360;
float _686366;
_686366 = *_686365;
float _686371;
_686371 = *_686370;
float _686380;
_686380 = *_686379;
float _686386;
_686386 = *_686385;
float _686392;
_686392 = *_686391;
float _686397;
_686397 = *_686396;
float _686402;
_686402 = *_686401;
float _686410;
_686410 = *_686409;
float _686416;
_686416 = *_686415;
float _686422;
_686422 = *_686421;
float _686427;
_686427 = *_686426;
float _686432;
_686432 = *_686431;
float _686440;
_686440 = *_686439;
float _686446;
_686446 = *_686445;
float _686452;
_686452 = *_686451;
float _686457;
_686457 = *_686456;
float _686462;
_686462 = *_686461;
float _686470;
_686470 = *_686469;
float _686476;
_686476 = *_686475;
float _686482;
_686482 = *_686481;
float _686487;
_686487 = *_686486;
float _686492;
_686492 = *_686491;
float _686500;
_686500 = *_686499;
float _686506;
_686506 = *_686505;
float _686512;
_686512 = *_686511;
float _686517;
_686517 = *_686516;
float _686522;
_686522 = *_686521;
float _686531;
_686531 = *_686530;
float _686537;
_686537 = *_686536;
float _686543;
_686543 = *_686542;
float _686548;
_686548 = *_686547;
float _686553;
_686553 = *_686552;
float _686561;
_686561 = *_686560;
float _686567;
_686567 = *_686566;
float _686573;
_686573 = *_686572;
float _686578;
_686578 = *_686577;
float _686583;
_686583 = *_686582;
float _686591;
_686591 = *_686590;
float _686597;
_686597 = *_686596;
float _686603;
_686603 = *_686602;
float _686608;
_686608 = *_686607;
float _686613;
_686613 = *_686612;
float _686621;
_686621 = *_686620;
float _686627;
_686627 = *_686626;
float _686633;
_686633 = *_686632;
float _686638;
_686638 = *_686637;
float _686643;
_686643 = *_686642;
float _686651;
_686651 = *_686650;
float _686657;
_686657 = *_686656;
float _686663;
_686663 = *_686662;
float _686668;
_686668 = *_686667;
float _686673;
_686673 = *_686672;
float _686682;
_686682 = *_686681;
float _686688;
_686688 = *_686687;
float _686694;
_686694 = *_686693;
float _686699;
_686699 = *_686698;
float _686704;
_686704 = *_686703;
float _686712;
_686712 = *_686711;
float _686718;
_686718 = *_686717;
float _686724;
_686724 = *_686723;
float _686729;
_686729 = *_686728;
float _686734;
_686734 = *_686733;
float _686742;
_686742 = *_686741;
float _686748;
_686748 = *_686747;
float _686754;
_686754 = *_686753;
float _686759;
_686759 = *_686758;
float _686764;
_686764 = *_686763;
float _686772;
_686772 = *_686771;
float _686778;
_686778 = *_686777;
float _686784;
_686784 = *_686783;
float _686789;
_686789 = *_686788;
float _686794;
_686794 = *_686793;
float _686802;
_686802 = *_686801;
float _686808;
_686808 = *_686807;
float _686814;
_686814 = *_686813;
float _686819;
_686819 = *_686818;
float _686824;
_686824 = *_686823;
float _686833;
_686833 = *_686832;
float _686839;
_686839 = *_686838;
float _686845;
_686845 = *_686844;
float _686850;
_686850 = *_686849;
float _686855;
_686855 = *_686854;
float _686863;
_686863 = *_686862;
float _686869;
_686869 = *_686868;
float _686875;
_686875 = *_686874;
float _686880;
_686880 = *_686879;
float _686885;
_686885 = *_686884;
float _686893;
_686893 = *_686892;
float _686899;
_686899 = *_686898;
float _686905;
_686905 = *_686904;
float _686910;
_686910 = *_686909;
float _686915;
_686915 = *_686914;
float _686923;
_686923 = *_686922;
float _686929;
_686929 = *_686928;
float _686935;
_686935 = *_686934;
float _686940;
_686940 = *_686939;
float _686945;
_686945 = *_686944;
float _686953;
_686953 = *_686952;
float _686959;
_686959 = *_686958;
float _686965;
_686965 = *_686964;
float _686970;
_686970 = *_686969;
float _686975;
_686975 = *_686974;
float _686984;
_686984 = *_686983;
float _686990;
_686990 = *_686989;
float _686996;
_686996 = *_686995;
float _687001;
_687001 = *_687000;
float _687006;
_687006 = *_687005;
float _687014;
_687014 = *_687013;
float _687020;
_687020 = *_687019;
float _687026;
_687026 = *_687025;
float _687031;
_687031 = *_687030;
float _687036;
_687036 = *_687035;
float _687044;
_687044 = *_687043;
float _687050;
_687050 = *_687049;
float _687056;
_687056 = *_687055;
float _687061;
_687061 = *_687060;
float _687066;
_687066 = *_687065;
float _687074;
_687074 = *_687073;
float _687080;
_687080 = *_687079;
float _687086;
_687086 = *_687085;
float _687091;
_687091 = *_687090;
float _687096;
_687096 = *_687095;
float _687104;
_687104 = *_687103;
float _687110;
_687110 = *_687109;
float _687116;
_687116 = *_687115;
float _687121;
_687121 = *_687120;
float _687126;
_687126 = *_687125;
float _687135;
_687135 = *_687134;
float _687141;
_687141 = *_687140;
float _687147;
_687147 = *_687146;
float _687152;
_687152 = *_687151;
float _687157;
_687157 = *_687156;
float _687165;
_687165 = *_687164;
float _687171;
_687171 = *_687170;
float _687177;
_687177 = *_687176;
float _687182;
_687182 = *_687181;
float _687187;
_687187 = *_687186;
float _687195;
_687195 = *_687194;
float _687201;
_687201 = *_687200;
float _687207;
_687207 = *_687206;
float _687212;
_687212 = *_687211;
float _687217;
_687217 = *_687216;
float _687225;
_687225 = *_687224;
float _687231;
_687231 = *_687230;
float _687237;
_687237 = *_687236;
float _687242;
_687242 = *_687241;
float _687247;
_687247 = *_687246;
float _687255;
_687255 = *_687254;
float _687261;
_687261 = *_687260;
float _687267;
_687267 = *_687266;
float _687272;
_687272 = *_687271;
float _687277;
_687277 = *_687276;
float _687286;
_687286 = *_687285;
float _687292;
_687292 = *_687291;
float _687298;
_687298 = *_687297;
float _687303;
_687303 = *_687302;
float _687308;
_687308 = *_687307;
float _687316;
_687316 = *_687315;
float _687322;
_687322 = *_687321;
float _687328;
_687328 = *_687327;
float _687333;
_687333 = *_687332;
float _687338;
_687338 = *_687337;
float _687346;
_687346 = *_687345;
float _687352;
_687352 = *_687351;
float _687358;
_687358 = *_687357;
float _687363;
_687363 = *_687362;
float _687368;
_687368 = *_687367;
float _687376;
_687376 = *_687375;
float _687382;
_687382 = *_687381;
float _687388;
_687388 = *_687387;
float _687393;
_687393 = *_687392;
float _687398;
_687398 = *_687397;
float _687406;
_687406 = *_687405;
float _687412;
_687412 = *_687411;
float _687418;
_687418 = *_687417;
float _687423;
_687423 = *_687422;
float _687428;
_687428 = *_687427;
float _687437;
_687437 = *_687436;
float _687443;
_687443 = *_687442;
float _687449;
_687449 = *_687448;
float _687454;
_687454 = *_687453;
float _687459;
_687459 = *_687458;
float _687467;
_687467 = *_687466;
float _687473;
_687473 = *_687472;
float _687479;
_687479 = *_687478;
float _687484;
_687484 = *_687483;
float _687489;
_687489 = *_687488;
float _687497;
_687497 = *_687496;
float _687503;
_687503 = *_687502;
float _687509;
_687509 = *_687508;
float _687514;
_687514 = *_687513;
float _687519;
_687519 = *_687518;
float _687527;
_687527 = *_687526;
float _687533;
_687533 = *_687532;
float _687539;
_687539 = *_687538;
float _687544;
_687544 = *_687543;
float _687549;
_687549 = *_687548;
float _687557;
_687557 = *_687556;
float _687563;
_687563 = *_687562;
float _687569;
_687569 = *_687568;
float _687574;
_687574 = *_687573;
float _687579;
_687579 = *_687578;
float _687588;
_687588 = *_687587;
float _687594;
_687594 = *_687593;
float _687600;
_687600 = *_687599;
float _687605;
_687605 = *_687604;
float _687610;
_687610 = *_687609;
float _687618;
_687618 = *_687617;
float _687624;
_687624 = *_687623;
float _687630;
_687630 = *_687629;
float _687635;
_687635 = *_687634;
float _687640;
_687640 = *_687639;
float _687648;
_687648 = *_687647;
float _687654;
_687654 = *_687653;
float _687660;
_687660 = *_687659;
float _687665;
_687665 = *_687664;
float _687670;
_687670 = *_687669;
float _687678;
_687678 = *_687677;
float _687684;
_687684 = *_687683;
float _687690;
_687690 = *_687689;
float _687695;
_687695 = *_687694;
float _687700;
_687700 = *_687699;
float _687708;
_687708 = *_687707;
float _687714;
_687714 = *_687713;
float _687720;
_687720 = *_687719;
float _687725;
_687725 = *_687724;
float _687730;
_687730 = *_687729;
float _687739;
_687739 = *_687738;
float _687745;
_687745 = *_687744;
float _687751;
_687751 = *_687750;
float _687756;
_687756 = *_687755;
float _687761;
_687761 = *_687760;
float _687769;
_687769 = *_687768;
float _687775;
_687775 = *_687774;
float _687781;
_687781 = *_687780;
float _687786;
_687786 = *_687785;
float _687791;
_687791 = *_687790;
float _687799;
_687799 = *_687798;
float _687805;
_687805 = *_687804;
float _687811;
_687811 = *_687810;
float _687816;
_687816 = *_687815;
float _687821;
_687821 = *_687820;
float _687829;
_687829 = *_687828;
float _687835;
_687835 = *_687834;
float _687841;
_687841 = *_687840;
float _687846;
_687846 = *_687845;
float _687851;
_687851 = *_687850;
float _687859;
_687859 = *_687858;
float _687865;
_687865 = *_687864;
float _687871;
_687871 = *_687870;
float _687876;
_687876 = *_687875;
float _687881;
_687881 = *_687880;
float _687890;
_687890 = *_687889;
float _687896;
_687896 = *_687895;
float _687902;
_687902 = *_687901;
float _687907;
_687907 = *_687906;
float _687912;
_687912 = *_687911;
float _687920;
_687920 = *_687919;
float _687926;
_687926 = *_687925;
float _687932;
_687932 = *_687931;
float _687937;
_687937 = *_687936;
float _687942;
_687942 = *_687941;
float _687950;
_687950 = *_687949;
float _687956;
_687956 = *_687955;
float _687962;
_687962 = *_687961;
float _687967;
_687967 = *_687966;
float _687972;
_687972 = *_687971;
float _687980;
_687980 = *_687979;
float _687986;
_687986 = *_687985;
float _687992;
_687992 = *_687991;
float _687997;
_687997 = *_687996;
float _688002;
_688002 = *_688001;
float _688010;
_688010 = *_688009;
float _688016;
_688016 = *_688015;
float _688022;
_688022 = *_688021;
float _688027;
_688027 = *_688026;
float _688032;
_688032 = *_688031;
float _688034;
_688034 = *_681214;
float _688035;
_688035 = _688034;
bool _688036;
_688036 = _688035 < 0.000000e+00f;
if (_688036) goto l688037; else goto l702561;
l702561: ;
bool _702562;
_702562 = 1.000000e+00f <= _688035;
if (_702562) goto l702563; else goto l702566;
l702566: ;
pconverge_702565 = _688035;
goto l702564;
l702563: ;
pconverge_702565 = 1.000000e+00f;
goto l702564;
l702564: ;
converge_702565 = pconverge_702565;
pconverge_688039 = converge_702565;
goto l688038;
l688037: ;
pconverge_688039 = 0.000000e+00f;
goto l688038;
l688038: ;
converge_688039 = pconverge_688039;
if (_681228) goto l688040; else goto l702556;
l702556: ;
if (_701806) goto l702557; else goto l702560;
l702560: ;
pconverge_702559 = _681226;
goto l702558;
l702557: ;
pconverge_702559 = _701379;
goto l702558;
l702558: ;
converge_702559 = pconverge_702559;
pconverge_688042 = converge_702559;
goto l688041;
l688040: ;
pconverge_688042 = 0;
goto l688041;
l688041: ;
converge_688042 = pconverge_688042;
if (_681234) goto l688043; else goto l702551;
l702551: ;
if (_701528) goto l702552; else goto l702555;
l702555: ;
pconverge_702554 = _681233;
goto l702553;
l702552: ;
pconverge_702554 = _701347;
goto l702553;
l702553: ;
converge_702554 = pconverge_702554;
pconverge_688045 = converge_702554;
goto l688044;
l688043: ;
pconverge_688045 = 0;
goto l688044;
l688044: ;
converge_688045 = pconverge_688045;
if (_681240) goto l688046; else goto l702546;
l702546: ;
if (_701522) goto l702547; else goto l702550;
l702550: ;
pconverge_702549 = _681239;
goto l702548;
l702547: ;
pconverge_702549 = _701347;
goto l702548;
l702548: ;
converge_702549 = pconverge_702549;
pconverge_688048 = converge_702549;
goto l688047;
l688046: ;
pconverge_688048 = 0;
goto l688047;
l688047: ;
converge_688048 = pconverge_688048;
if (_681244) goto l688049; else goto l702541;
l702541: ;
if (_701516) goto l702542; else goto l702545;
l702545: ;
pconverge_702544 = xi_681232;
goto l702543;
l702542: ;
pconverge_702544 = _701347;
goto l702543;
l702543: ;
converge_702544 = pconverge_702544;
pconverge_688051 = converge_702544;
goto l688050;
l688049: ;
pconverge_688051 = 0;
goto l688050;
l688050: ;
converge_688051 = pconverge_688051;
if (_681249) goto l688052; else goto l702536;
l702536: ;
if (_701356) goto l702537; else goto l702540;
l702540: ;
pconverge_702539 = _681248;
goto l702538;
l702537: ;
pconverge_702539 = _701347;
goto l702538;
l702538: ;
converge_702539 = pconverge_702539;
pconverge_688054 = converge_702539;
goto l688053;
l688052: ;
pconverge_688054 = 0;
goto l688053;
l688053: ;
converge_688054 = pconverge_688054;
if (_681254) goto l688055; else goto l702531;
l702531: ;
if (_701350) goto l702532; else goto l702535;
l702535: ;
pconverge_702534 = _681253;
goto l702533;
l702532: ;
pconverge_702534 = _701347;
goto l702533;
l702533: ;
converge_702534 = pconverge_702534;
pconverge_688057 = converge_702534;
goto l688056;
l688055: ;
pconverge_688057 = 0;
goto l688056;
l688056: ;
converge_688057 = pconverge_688057;
if (_681259) goto l688058; else goto l702526;
l702526: ;
if (_701775) goto l702527; else goto l702530;
l702530: ;
pconverge_702529 = _681258;
goto l702528;
l702527: ;
pconverge_702529 = _701379;
goto l702528;
l702528: ;
converge_702529 = pconverge_702529;
pconverge_688060 = converge_702529;
goto l688059;
l688058: ;
pconverge_688060 = 0;
goto l688059;
l688059: ;
converge_688060 = pconverge_688060;
if (_681234) goto l688061; else goto l702521;
l702521: ;
if (_701528) goto l702522; else goto l702525;
l702525: ;
pconverge_702524 = _681233;
goto l702523;
l702522: ;
pconverge_702524 = _701347;
goto l702523;
l702523: ;
converge_702524 = pconverge_702524;
pconverge_688063 = converge_702524;
goto l688062;
l688061: ;
pconverge_688063 = 0;
goto l688062;
l688062: ;
converge_688063 = pconverge_688063;
if (_681240) goto l688064; else goto l702516;
l702516: ;
if (_701522) goto l702517; else goto l702520;
l702520: ;
pconverge_702519 = _681239;
goto l702518;
l702517: ;
pconverge_702519 = _701347;
goto l702518;
l702518: ;
converge_702519 = pconverge_702519;
pconverge_688066 = converge_702519;
goto l688065;
l688064: ;
pconverge_688066 = 0;
goto l688065;
l688065: ;
converge_688066 = pconverge_688066;
if (_681244) goto l688067; else goto l702511;
l702511: ;
if (_701516) goto l702512; else goto l702515;
l702515: ;
pconverge_702514 = xi_681232;
goto l702513;
l702512: ;
pconverge_702514 = _701347;
goto l702513;
l702513: ;
converge_702514 = pconverge_702514;
pconverge_688069 = converge_702514;
goto l688068;
l688067: ;
pconverge_688069 = 0;
goto l688068;
l688068: ;
converge_688069 = pconverge_688069;
if (_681249) goto l688070; else goto l702506;
l702506: ;
if (_701356) goto l702507; else goto l702510;
l702510: ;
pconverge_702509 = _681248;
goto l702508;
l702507: ;
pconverge_702509 = _701347;
goto l702508;
l702508: ;
converge_702509 = pconverge_702509;
pconverge_688072 = converge_702509;
goto l688071;
l688070: ;
pconverge_688072 = 0;
goto l688071;
l688071: ;
converge_688072 = pconverge_688072;
if (_681254) goto l688073; else goto l702501;
l702501: ;
if (_701350) goto l702502; else goto l702505;
l702505: ;
pconverge_702504 = _681253;
goto l702503;
l702502: ;
pconverge_702504 = _701347;
goto l702503;
l702503: ;
converge_702504 = pconverge_702504;
pconverge_688075 = converge_702504;
goto l688074;
l688073: ;
pconverge_688075 = 0;
goto l688074;
l688074: ;
converge_688075 = pconverge_688075;
if (_681278) goto l688076; else goto l702496;
l702496: ;
if (_701744) goto l702497; else goto l702500;
l702500: ;
pconverge_702499 = yi_681224;
goto l702498;
l702497: ;
pconverge_702499 = _701379;
goto l702498;
l702498: ;
converge_702499 = pconverge_702499;
pconverge_688078 = converge_702499;
goto l688077;
l688076: ;
pconverge_688078 = 0;
goto l688077;
l688077: ;
converge_688078 = pconverge_688078;
if (_681234) goto l688079; else goto l702491;
l702491: ;
if (_701528) goto l702492; else goto l702495;
l702495: ;
pconverge_702494 = _681233;
goto l702493;
l702492: ;
pconverge_702494 = _701347;
goto l702493;
l702493: ;
converge_702494 = pconverge_702494;
pconverge_688081 = converge_702494;
goto l688080;
l688079: ;
pconverge_688081 = 0;
goto l688080;
l688080: ;
converge_688081 = pconverge_688081;
if (_681240) goto l688082; else goto l702486;
l702486: ;
if (_701522) goto l702487; else goto l702490;
l702490: ;
pconverge_702489 = _681239;
goto l702488;
l702487: ;
pconverge_702489 = _701347;
goto l702488;
l702488: ;
converge_702489 = pconverge_702489;
pconverge_688084 = converge_702489;
goto l688083;
l688082: ;
pconverge_688084 = 0;
goto l688083;
l688083: ;
converge_688084 = pconverge_688084;
if (_681244) goto l688085; else goto l702481;
l702481: ;
if (_701516) goto l702482; else goto l702485;
l702485: ;
pconverge_702484 = xi_681232;
goto l702483;
l702482: ;
pconverge_702484 = _701347;
goto l702483;
l702483: ;
converge_702484 = pconverge_702484;
pconverge_688087 = converge_702484;
goto l688086;
l688085: ;
pconverge_688087 = 0;
goto l688086;
l688086: ;
converge_688087 = pconverge_688087;
if (_681249) goto l688088; else goto l702476;
l702476: ;
if (_701356) goto l702477; else goto l702480;
l702480: ;
pconverge_702479 = _681248;
goto l702478;
l702477: ;
pconverge_702479 = _701347;
goto l702478;
l702478: ;
converge_702479 = pconverge_702479;
pconverge_688090 = converge_702479;
goto l688089;
l688088: ;
pconverge_688090 = 0;
goto l688089;
l688089: ;
converge_688090 = pconverge_688090;
if (_681254) goto l688091; else goto l702471;
l702471: ;
if (_701350) goto l702472; else goto l702475;
l702475: ;
pconverge_702474 = _681253;
goto l702473;
l702472: ;
pconverge_702474 = _701347;
goto l702473;
l702473: ;
converge_702474 = pconverge_702474;
pconverge_688093 = converge_702474;
goto l688092;
l688091: ;
pconverge_688093 = 0;
goto l688092;
l688092: ;
converge_688093 = pconverge_688093;
if (_681298) goto l688094; else goto l702466;
l702466: ;
if (_701438) goto l702467; else goto l702470;
l702470: ;
pconverge_702469 = _681297;
goto l702468;
l702467: ;
pconverge_702469 = _701379;
goto l702468;
l702468: ;
converge_702469 = pconverge_702469;
pconverge_688096 = converge_702469;
goto l688095;
l688094: ;
pconverge_688096 = 0;
goto l688095;
l688095: ;
converge_688096 = pconverge_688096;
if (_681234) goto l688097; else goto l702461;
l702461: ;
if (_701528) goto l702462; else goto l702465;
l702465: ;
pconverge_702464 = _681233;
goto l702463;
l702462: ;
pconverge_702464 = _701347;
goto l702463;
l702463: ;
converge_702464 = pconverge_702464;
pconverge_688099 = converge_702464;
goto l688098;
l688097: ;
pconverge_688099 = 0;
goto l688098;
l688098: ;
converge_688099 = pconverge_688099;
if (_681240) goto l688100; else goto l702456;
l702456: ;
if (_701522) goto l702457; else goto l702460;
l702460: ;
pconverge_702459 = _681239;
goto l702458;
l702457: ;
pconverge_702459 = _701347;
goto l702458;
l702458: ;
converge_702459 = pconverge_702459;
pconverge_688102 = converge_702459;
goto l688101;
l688100: ;
pconverge_688102 = 0;
goto l688101;
l688101: ;
converge_688102 = pconverge_688102;
if (_681244) goto l688103; else goto l702451;
l702451: ;
if (_701516) goto l702452; else goto l702455;
l702455: ;
pconverge_702454 = xi_681232;
goto l702453;
l702452: ;
pconverge_702454 = _701347;
goto l702453;
l702453: ;
converge_702454 = pconverge_702454;
pconverge_688105 = converge_702454;
goto l688104;
l688103: ;
pconverge_688105 = 0;
goto l688104;
l688104: ;
converge_688105 = pconverge_688105;
if (_681249) goto l688106; else goto l702446;
l702446: ;
if (_701356) goto l702447; else goto l702450;
l702450: ;
pconverge_702449 = _681248;
goto l702448;
l702447: ;
pconverge_702449 = _701347;
goto l702448;
l702448: ;
converge_702449 = pconverge_702449;
pconverge_688108 = converge_702449;
goto l688107;
l688106: ;
pconverge_688108 = 0;
goto l688107;
l688107: ;
converge_688108 = pconverge_688108;
if (_681254) goto l688109; else goto l702441;
l702441: ;
if (_701350) goto l702442; else goto l702445;
l702445: ;
pconverge_702444 = _681253;
goto l702443;
l702442: ;
pconverge_702444 = _701347;
goto l702443;
l702443: ;
converge_702444 = pconverge_702444;
pconverge_688111 = converge_702444;
goto l688110;
l688109: ;
pconverge_688111 = 0;
goto l688110;
l688110: ;
converge_688111 = pconverge_688111;
if (_681318) goto l688112; else goto l702436;
l702436: ;
if (_701407) goto l702437; else goto l702440;
l702440: ;
pconverge_702439 = _681317;
goto l702438;
l702437: ;
pconverge_702439 = _701379;
goto l702438;
l702438: ;
converge_702439 = pconverge_702439;
pconverge_688114 = converge_702439;
goto l688113;
l688112: ;
pconverge_688114 = 0;
goto l688113;
l688113: ;
converge_688114 = pconverge_688114;
if (_681234) goto l688115; else goto l702431;
l702431: ;
if (_701528) goto l702432; else goto l702435;
l702435: ;
pconverge_702434 = _681233;
goto l702433;
l702432: ;
pconverge_702434 = _701347;
goto l702433;
l702433: ;
converge_702434 = pconverge_702434;
pconverge_688117 = converge_702434;
goto l688116;
l688115: ;
pconverge_688117 = 0;
goto l688116;
l688116: ;
converge_688117 = pconverge_688117;
if (_681240) goto l688118; else goto l702426;
l702426: ;
if (_701522) goto l702427; else goto l702430;
l702430: ;
pconverge_702429 = _681239;
goto l702428;
l702427: ;
pconverge_702429 = _701347;
goto l702428;
l702428: ;
converge_702429 = pconverge_702429;
pconverge_688120 = converge_702429;
goto l688119;
l688118: ;
pconverge_688120 = 0;
goto l688119;
l688119: ;
converge_688120 = pconverge_688120;
if (_681244) goto l688121; else goto l702421;
l702421: ;
if (_701516) goto l702422; else goto l702425;
l702425: ;
pconverge_702424 = xi_681232;
goto l702423;
l702422: ;
pconverge_702424 = _701347;
goto l702423;
l702423: ;
converge_702424 = pconverge_702424;
pconverge_688123 = converge_702424;
goto l688122;
l688121: ;
pconverge_688123 = 0;
goto l688122;
l688122: ;
converge_688123 = pconverge_688123;
if (_681249) goto l688124; else goto l702416;
l702416: ;
if (_701356) goto l702417; else goto l702420;
l702420: ;
pconverge_702419 = _681248;
goto l702418;
l702417: ;
pconverge_702419 = _701347;
goto l702418;
l702418: ;
converge_702419 = pconverge_702419;
pconverge_688126 = converge_702419;
goto l688125;
l688124: ;
pconverge_688126 = 0;
goto l688125;
l688125: ;
converge_688126 = pconverge_688126;
if (_681254) goto l688127; else goto l702411;
l702411: ;
if (_701350) goto l702412; else goto l702415;
l702415: ;
pconverge_702414 = _681253;
goto l702413;
l702412: ;
pconverge_702414 = _701347;
goto l702413;
l702413: ;
converge_702414 = pconverge_702414;
pconverge_688129 = converge_702414;
goto l688128;
l688127: ;
pconverge_688129 = 0;
goto l688128;
l688128: ;
converge_688129 = pconverge_688129;
if (_681228) goto l688130; else goto l702406;
l702406: ;
if (_701806) goto l702407; else goto l702410;
l702410: ;
pconverge_702409 = _681226;
goto l702408;
l702407: ;
pconverge_702409 = _701379;
goto l702408;
l702408: ;
converge_702409 = pconverge_702409;
pconverge_688132 = converge_702409;
goto l688131;
l688130: ;
pconverge_688132 = 0;
goto l688131;
l688131: ;
converge_688132 = pconverge_688132;
if (_681341) goto l688133; else goto l702401;
l702401: ;
if (_701368) goto l702402; else goto l702405;
l702405: ;
pconverge_702404 = _681340;
goto l702403;
l702402: ;
pconverge_702404 = _701347;
goto l702403;
l702403: ;
converge_702404 = pconverge_702404;
pconverge_688135 = converge_702404;
goto l688134;
l688133: ;
pconverge_688135 = 0;
goto l688134;
l688134: ;
converge_688135 = pconverge_688135;
if (_681346) goto l688136; else goto l702396;
l702396: ;
if (_701362) goto l702397; else goto l702400;
l702400: ;
pconverge_702399 = _681345;
goto l702398;
l702397: ;
pconverge_702399 = _701347;
goto l702398;
l702398: ;
converge_702399 = pconverge_702399;
pconverge_688138 = converge_702399;
goto l688137;
l688136: ;
pconverge_688138 = 0;
goto l688137;
l688137: ;
converge_688138 = pconverge_688138;
if (_681249) goto l688139; else goto l702391;
l702391: ;
if (_701356) goto l702392; else goto l702395;
l702395: ;
pconverge_702394 = _681248;
goto l702393;
l702392: ;
pconverge_702394 = _701347;
goto l702393;
l702393: ;
converge_702394 = pconverge_702394;
pconverge_688141 = converge_702394;
goto l688140;
l688139: ;
pconverge_688141 = 0;
goto l688140;
l688140: ;
converge_688141 = pconverge_688141;
if (_681254) goto l688142; else goto l702386;
l702386: ;
if (_701350) goto l702387; else goto l702390;
l702390: ;
pconverge_702389 = _681253;
goto l702388;
l702387: ;
pconverge_702389 = _701347;
goto l702388;
l702388: ;
converge_702389 = pconverge_702389;
pconverge_688144 = converge_702389;
goto l688143;
l688142: ;
pconverge_688144 = 0;
goto l688143;
l688143: ;
converge_688144 = pconverge_688144;
if (_681358) goto l688145; else goto l702381;
l702381: ;
if (_701343) goto l702382; else goto l702385;
l702385: ;
pconverge_702384 = _681357;
goto l702383;
l702382: ;
pconverge_702384 = _701347;
goto l702383;
l702383: ;
converge_702384 = pconverge_702384;
pconverge_688147 = converge_702384;
goto l688146;
l688145: ;
pconverge_688147 = 0;
goto l688146;
l688146: ;
converge_688147 = pconverge_688147;
if (_681259) goto l688148; else goto l702376;
l702376: ;
if (_701775) goto l702377; else goto l702380;
l702380: ;
pconverge_702379 = _681258;
goto l702378;
l702377: ;
pconverge_702379 = _701379;
goto l702378;
l702378: ;
converge_702379 = pconverge_702379;
pconverge_688150 = converge_702379;
goto l688149;
l688148: ;
pconverge_688150 = 0;
goto l688149;
l688149: ;
converge_688150 = pconverge_688150;
if (_681341) goto l688151; else goto l702371;
l702371: ;
if (_701368) goto l702372; else goto l702375;
l702375: ;
pconverge_702374 = _681340;
goto l702373;
l702372: ;
pconverge_702374 = _701347;
goto l702373;
l702373: ;
converge_702374 = pconverge_702374;
pconverge_688153 = converge_702374;
goto l688152;
l688151: ;
pconverge_688153 = 0;
goto l688152;
l688152: ;
converge_688153 = pconverge_688153;
if (_681346) goto l688154; else goto l702366;
l702366: ;
if (_701362) goto l702367; else goto l702370;
l702370: ;
pconverge_702369 = _681345;
goto l702368;
l702367: ;
pconverge_702369 = _701347;
goto l702368;
l702368: ;
converge_702369 = pconverge_702369;
pconverge_688156 = converge_702369;
goto l688155;
l688154: ;
pconverge_688156 = 0;
goto l688155;
l688155: ;
converge_688156 = pconverge_688156;
if (_681249) goto l688157; else goto l702361;
l702361: ;
if (_701356) goto l702362; else goto l702365;
l702365: ;
pconverge_702364 = _681248;
goto l702363;
l702362: ;
pconverge_702364 = _701347;
goto l702363;
l702363: ;
converge_702364 = pconverge_702364;
pconverge_688159 = converge_702364;
goto l688158;
l688157: ;
pconverge_688159 = 0;
goto l688158;
l688158: ;
converge_688159 = pconverge_688159;
if (_681254) goto l688160; else goto l702356;
l702356: ;
if (_701350) goto l702357; else goto l702360;
l702360: ;
pconverge_702359 = _681253;
goto l702358;
l702357: ;
pconverge_702359 = _701347;
goto l702358;
l702358: ;
converge_702359 = pconverge_702359;
pconverge_688162 = converge_702359;
goto l688161;
l688160: ;
pconverge_688162 = 0;
goto l688161;
l688161: ;
converge_688162 = pconverge_688162;
if (_681358) goto l688163; else goto l702351;
l702351: ;
if (_701343) goto l702352; else goto l702355;
l702355: ;
pconverge_702354 = _681357;
goto l702353;
l702352: ;
pconverge_702354 = _701347;
goto l702353;
l702353: ;
converge_702354 = pconverge_702354;
pconverge_688165 = converge_702354;
goto l688164;
l688163: ;
pconverge_688165 = 0;
goto l688164;
l688164: ;
converge_688165 = pconverge_688165;
if (_681278) goto l688166; else goto l702346;
l702346: ;
if (_701744) goto l702347; else goto l702350;
l702350: ;
pconverge_702349 = yi_681224;
goto l702348;
l702347: ;
pconverge_702349 = _701379;
goto l702348;
l702348: ;
converge_702349 = pconverge_702349;
pconverge_688168 = converge_702349;
goto l688167;
l688166: ;
pconverge_688168 = 0;
goto l688167;
l688167: ;
converge_688168 = pconverge_688168;
if (_681341) goto l688169; else goto l702341;
l702341: ;
if (_701368) goto l702342; else goto l702345;
l702345: ;
pconverge_702344 = _681340;
goto l702343;
l702342: ;
pconverge_702344 = _701347;
goto l702343;
l702343: ;
converge_702344 = pconverge_702344;
pconverge_688171 = converge_702344;
goto l688170;
l688169: ;
pconverge_688171 = 0;
goto l688170;
l688170: ;
converge_688171 = pconverge_688171;
if (_681346) goto l688172; else goto l702336;
l702336: ;
if (_701362) goto l702337; else goto l702340;
l702340: ;
pconverge_702339 = _681345;
goto l702338;
l702337: ;
pconverge_702339 = _701347;
goto l702338;
l702338: ;
converge_702339 = pconverge_702339;
pconverge_688174 = converge_702339;
goto l688173;
l688172: ;
pconverge_688174 = 0;
goto l688173;
l688173: ;
converge_688174 = pconverge_688174;
if (_681249) goto l688175; else goto l702331;
l702331: ;
if (_701356) goto l702332; else goto l702335;
l702335: ;
pconverge_702334 = _681248;
goto l702333;
l702332: ;
pconverge_702334 = _701347;
goto l702333;
l702333: ;
converge_702334 = pconverge_702334;
pconverge_688177 = converge_702334;
goto l688176;
l688175: ;
pconverge_688177 = 0;
goto l688176;
l688176: ;
converge_688177 = pconverge_688177;
if (_681254) goto l688178; else goto l702326;
l702326: ;
if (_701350) goto l702327; else goto l702330;
l702330: ;
pconverge_702329 = _681253;
goto l702328;
l702327: ;
pconverge_702329 = _701347;
goto l702328;
l702328: ;
converge_702329 = pconverge_702329;
pconverge_688180 = converge_702329;
goto l688179;
l688178: ;
pconverge_688180 = 0;
goto l688179;
l688179: ;
converge_688180 = pconverge_688180;
if (_681358) goto l688181; else goto l702321;
l702321: ;
if (_701343) goto l702322; else goto l702325;
l702325: ;
pconverge_702324 = _681357;
goto l702323;
l702322: ;
pconverge_702324 = _701347;
goto l702323;
l702323: ;
converge_702324 = pconverge_702324;
pconverge_688183 = converge_702324;
goto l688182;
l688181: ;
pconverge_688183 = 0;
goto l688182;
l688182: ;
converge_688183 = pconverge_688183;
if (_681298) goto l688184; else goto l702316;
l702316: ;
if (_701438) goto l702317; else goto l702320;
l702320: ;
pconverge_702319 = _681297;
goto l702318;
l702317: ;
pconverge_702319 = _701379;
goto l702318;
l702318: ;
converge_702319 = pconverge_702319;
pconverge_688186 = converge_702319;
goto l688185;
l688184: ;
pconverge_688186 = 0;
goto l688185;
l688185: ;
converge_688186 = pconverge_688186;
if (_681341) goto l688187; else goto l702311;
l702311: ;
if (_701368) goto l702312; else goto l702315;
l702315: ;
pconverge_702314 = _681340;
goto l702313;
l702312: ;
pconverge_702314 = _701347;
goto l702313;
l702313: ;
converge_702314 = pconverge_702314;
pconverge_688189 = converge_702314;
goto l688188;
l688187: ;
pconverge_688189 = 0;
goto l688188;
l688188: ;
converge_688189 = pconverge_688189;
if (_681346) goto l688190; else goto l702306;
l702306: ;
if (_701362) goto l702307; else goto l702310;
l702310: ;
pconverge_702309 = _681345;
goto l702308;
l702307: ;
pconverge_702309 = _701347;
goto l702308;
l702308: ;
converge_702309 = pconverge_702309;
pconverge_688192 = converge_702309;
goto l688191;
l688190: ;
pconverge_688192 = 0;
goto l688191;
l688191: ;
converge_688192 = pconverge_688192;
if (_681249) goto l688193; else goto l702301;
l702301: ;
if (_701356) goto l702302; else goto l702305;
l702305: ;
pconverge_702304 = _681248;
goto l702303;
l702302: ;
pconverge_702304 = _701347;
goto l702303;
l702303: ;
converge_702304 = pconverge_702304;
pconverge_688195 = converge_702304;
goto l688194;
l688193: ;
pconverge_688195 = 0;
goto l688194;
l688194: ;
converge_688195 = pconverge_688195;
if (_681254) goto l688196; else goto l702296;
l702296: ;
if (_701350) goto l702297; else goto l702300;
l702300: ;
pconverge_702299 = _681253;
goto l702298;
l702297: ;
pconverge_702299 = _701347;
goto l702298;
l702298: ;
converge_702299 = pconverge_702299;
pconverge_688198 = converge_702299;
goto l688197;
l688196: ;
pconverge_688198 = 0;
goto l688197;
l688197: ;
converge_688198 = pconverge_688198;
if (_681358) goto l688199; else goto l702291;
l702291: ;
if (_701343) goto l702292; else goto l702295;
l702295: ;
pconverge_702294 = _681357;
goto l702293;
l702292: ;
pconverge_702294 = _701347;
goto l702293;
l702293: ;
converge_702294 = pconverge_702294;
pconverge_688201 = converge_702294;
goto l688200;
l688199: ;
pconverge_688201 = 0;
goto l688200;
l688200: ;
converge_688201 = pconverge_688201;
if (_681318) goto l688202; else goto l702286;
l702286: ;
if (_701407) goto l702287; else goto l702290;
l702290: ;
pconverge_702289 = _681317;
goto l702288;
l702287: ;
pconverge_702289 = _701379;
goto l702288;
l702288: ;
converge_702289 = pconverge_702289;
pconverge_688204 = converge_702289;
goto l688203;
l688202: ;
pconverge_688204 = 0;
goto l688203;
l688203: ;
converge_688204 = pconverge_688204;
if (_681341) goto l688205; else goto l702281;
l702281: ;
if (_701368) goto l702282; else goto l702285;
l702285: ;
pconverge_702284 = _681340;
goto l702283;
l702282: ;
pconverge_702284 = _701347;
goto l702283;
l702283: ;
converge_702284 = pconverge_702284;
pconverge_688207 = converge_702284;
goto l688206;
l688205: ;
pconverge_688207 = 0;
goto l688206;
l688206: ;
converge_688207 = pconverge_688207;
if (_681346) goto l688208; else goto l702276;
l702276: ;
if (_701362) goto l702277; else goto l702280;
l702280: ;
pconverge_702279 = _681345;
goto l702278;
l702277: ;
pconverge_702279 = _701347;
goto l702278;
l702278: ;
converge_702279 = pconverge_702279;
pconverge_688210 = converge_702279;
goto l688209;
l688208: ;
pconverge_688210 = 0;
goto l688209;
l688209: ;
converge_688210 = pconverge_688210;
if (_681249) goto l688211; else goto l702271;
l702271: ;
if (_701356) goto l702272; else goto l702275;
l702275: ;
pconverge_702274 = _681248;
goto l702273;
l702272: ;
pconverge_702274 = _701347;
goto l702273;
l702273: ;
converge_702274 = pconverge_702274;
pconverge_688213 = converge_702274;
goto l688212;
l688211: ;
pconverge_688213 = 0;
goto l688212;
l688212: ;
converge_688213 = pconverge_688213;
if (_681254) goto l688214; else goto l702266;
l702266: ;
if (_701350) goto l702267; else goto l702270;
l702270: ;
pconverge_702269 = _681253;
goto l702268;
l702267: ;
pconverge_702269 = _701347;
goto l702268;
l702268: ;
converge_702269 = pconverge_702269;
pconverge_688216 = converge_702269;
goto l688215;
l688214: ;
pconverge_688216 = 0;
goto l688215;
l688215: ;
converge_688216 = pconverge_688216;
if (_681358) goto l688217; else goto l702261;
l702261: ;
if (_701343) goto l702262; else goto l702265;
l702265: ;
pconverge_702264 = _681357;
goto l702263;
l702262: ;
pconverge_702264 = _701347;
goto l702263;
l702263: ;
converge_702264 = pconverge_702264;
pconverge_688219 = converge_702264;
goto l688218;
l688217: ;
pconverge_688219 = 0;
goto l688218;
l688218: ;
converge_688219 = pconverge_688219;
if (_681435) goto l688220; else goto l702256;
l702256: ;
if (_701500) goto l702257; else goto l702260;
l702260: ;
pconverge_702259 = _681434;
goto l702258;
l702257: ;
pconverge_702259 = _701379;
goto l702258;
l702258: ;
converge_702259 = pconverge_702259;
pconverge_688222 = converge_702259;
goto l688221;
l688220: ;
pconverge_688222 = 0;
goto l688221;
l688221: ;
converge_688222 = pconverge_688222;
if (_681234) goto l688223; else goto l702251;
l702251: ;
if (_701528) goto l702252; else goto l702255;
l702255: ;
pconverge_702254 = _681233;
goto l702253;
l702252: ;
pconverge_702254 = _701347;
goto l702253;
l702253: ;
converge_702254 = pconverge_702254;
pconverge_688225 = converge_702254;
goto l688224;
l688223: ;
pconverge_688225 = 0;
goto l688224;
l688224: ;
converge_688225 = pconverge_688225;
if (_681240) goto l688226; else goto l702246;
l702246: ;
if (_701522) goto l702247; else goto l702250;
l702250: ;
pconverge_702249 = _681239;
goto l702248;
l702247: ;
pconverge_702249 = _701347;
goto l702248;
l702248: ;
converge_702249 = pconverge_702249;
pconverge_688228 = converge_702249;
goto l688227;
l688226: ;
pconverge_688228 = 0;
goto l688227;
l688227: ;
converge_688228 = pconverge_688228;
if (_681244) goto l688229; else goto l702241;
l702241: ;
if (_701516) goto l702242; else goto l702245;
l702245: ;
pconverge_702244 = xi_681232;
goto l702243;
l702242: ;
pconverge_702244 = _701347;
goto l702243;
l702243: ;
converge_702244 = pconverge_702244;
pconverge_688231 = converge_702244;
goto l688230;
l688229: ;
pconverge_688231 = 0;
goto l688230;
l688230: ;
converge_688231 = pconverge_688231;
if (_681249) goto l688232; else goto l702236;
l702236: ;
if (_701356) goto l702237; else goto l702240;
l702240: ;
pconverge_702239 = _681248;
goto l702238;
l702237: ;
pconverge_702239 = _701347;
goto l702238;
l702238: ;
converge_702239 = pconverge_702239;
pconverge_688234 = converge_702239;
goto l688233;
l688232: ;
pconverge_688234 = 0;
goto l688233;
l688233: ;
converge_688234 = pconverge_688234;
if (_681254) goto l688235; else goto l702231;
l702231: ;
if (_701350) goto l702232; else goto l702235;
l702235: ;
pconverge_702234 = _681253;
goto l702233;
l702232: ;
pconverge_702234 = _701347;
goto l702233;
l702233: ;
converge_702234 = pconverge_702234;
pconverge_688237 = converge_702234;
goto l688236;
l688235: ;
pconverge_688237 = 0;
goto l688236;
l688236: ;
converge_688237 = pconverge_688237;
if (_681455) goto l688238; else goto l702226;
l702226: ;
if (_701469) goto l702227; else goto l702230;
l702230: ;
pconverge_702229 = _681454;
goto l702228;
l702227: ;
pconverge_702229 = _701379;
goto l702228;
l702228: ;
converge_702229 = pconverge_702229;
pconverge_688240 = converge_702229;
goto l688239;
l688238: ;
pconverge_688240 = 0;
goto l688239;
l688239: ;
converge_688240 = pconverge_688240;
if (_681234) goto l688241; else goto l702221;
l702221: ;
if (_701528) goto l702222; else goto l702225;
l702225: ;
pconverge_702224 = _681233;
goto l702223;
l702222: ;
pconverge_702224 = _701347;
goto l702223;
l702223: ;
converge_702224 = pconverge_702224;
pconverge_688243 = converge_702224;
goto l688242;
l688241: ;
pconverge_688243 = 0;
goto l688242;
l688242: ;
converge_688243 = pconverge_688243;
if (_681240) goto l688244; else goto l702216;
l702216: ;
if (_701522) goto l702217; else goto l702220;
l702220: ;
pconverge_702219 = _681239;
goto l702218;
l702217: ;
pconverge_702219 = _701347;
goto l702218;
l702218: ;
converge_702219 = pconverge_702219;
pconverge_688246 = converge_702219;
goto l688245;
l688244: ;
pconverge_688246 = 0;
goto l688245;
l688245: ;
converge_688246 = pconverge_688246;
if (_681244) goto l688247; else goto l702211;
l702211: ;
if (_701516) goto l702212; else goto l702215;
l702215: ;
pconverge_702214 = xi_681232;
goto l702213;
l702212: ;
pconverge_702214 = _701347;
goto l702213;
l702213: ;
converge_702214 = pconverge_702214;
pconverge_688249 = converge_702214;
goto l688248;
l688247: ;
pconverge_688249 = 0;
goto l688248;
l688248: ;
converge_688249 = pconverge_688249;
if (_681249) goto l688250; else goto l702206;
l702206: ;
if (_701356) goto l702207; else goto l702210;
l702210: ;
pconverge_702209 = _681248;
goto l702208;
l702207: ;
pconverge_702209 = _701347;
goto l702208;
l702208: ;
converge_702209 = pconverge_702209;
pconverge_688252 = converge_702209;
goto l688251;
l688250: ;
pconverge_688252 = 0;
goto l688251;
l688251: ;
converge_688252 = pconverge_688252;
if (_681254) goto l688253; else goto l702201;
l702201: ;
if (_701350) goto l702202; else goto l702205;
l702205: ;
pconverge_702204 = _681253;
goto l702203;
l702202: ;
pconverge_702204 = _701347;
goto l702203;
l702203: ;
converge_702204 = pconverge_702204;
pconverge_688255 = converge_702204;
goto l688254;
l688253: ;
pconverge_688255 = 0;
goto l688254;
l688254: ;
converge_688255 = pconverge_688255;
if (_681298) goto l688256; else goto l702196;
l702196: ;
if (_701438) goto l702197; else goto l702200;
l702200: ;
pconverge_702199 = _681297;
goto l702198;
l702197: ;
pconverge_702199 = _701379;
goto l702198;
l702198: ;
converge_702199 = pconverge_702199;
pconverge_688258 = converge_702199;
goto l688257;
l688256: ;
pconverge_688258 = 0;
goto l688257;
l688257: ;
converge_688258 = pconverge_688258;
if (_681234) goto l688259; else goto l702191;
l702191: ;
if (_701528) goto l702192; else goto l702195;
l702195: ;
pconverge_702194 = _681233;
goto l702193;
l702192: ;
pconverge_702194 = _701347;
goto l702193;
l702193: ;
converge_702194 = pconverge_702194;
pconverge_688261 = converge_702194;
goto l688260;
l688259: ;
pconverge_688261 = 0;
goto l688260;
l688260: ;
converge_688261 = pconverge_688261;
if (_681240) goto l688262; else goto l702186;
l702186: ;
if (_701522) goto l702187; else goto l702190;
l702190: ;
pconverge_702189 = _681239;
goto l702188;
l702187: ;
pconverge_702189 = _701347;
goto l702188;
l702188: ;
converge_702189 = pconverge_702189;
pconverge_688264 = converge_702189;
goto l688263;
l688262: ;
pconverge_688264 = 0;
goto l688263;
l688263: ;
converge_688264 = pconverge_688264;
if (_681244) goto l688265; else goto l702181;
l702181: ;
if (_701516) goto l702182; else goto l702185;
l702185: ;
pconverge_702184 = xi_681232;
goto l702183;
l702182: ;
pconverge_702184 = _701347;
goto l702183;
l702183: ;
converge_702184 = pconverge_702184;
pconverge_688267 = converge_702184;
goto l688266;
l688265: ;
pconverge_688267 = 0;
goto l688266;
l688266: ;
converge_688267 = pconverge_688267;
if (_681249) goto l688268; else goto l702176;
l702176: ;
if (_701356) goto l702177; else goto l702180;
l702180: ;
pconverge_702179 = _681248;
goto l702178;
l702177: ;
pconverge_702179 = _701347;
goto l702178;
l702178: ;
converge_702179 = pconverge_702179;
pconverge_688270 = converge_702179;
goto l688269;
l688268: ;
pconverge_688270 = 0;
goto l688269;
l688269: ;
converge_688270 = pconverge_688270;
if (_681254) goto l688271; else goto l702171;
l702171: ;
if (_701350) goto l702172; else goto l702175;
l702175: ;
pconverge_702174 = _681253;
goto l702173;
l702172: ;
pconverge_702174 = _701347;
goto l702173;
l702173: ;
converge_702174 = pconverge_702174;
pconverge_688273 = converge_702174;
goto l688272;
l688271: ;
pconverge_688273 = 0;
goto l688272;
l688272: ;
converge_688273 = pconverge_688273;
if (_681318) goto l688274; else goto l702166;
l702166: ;
if (_701407) goto l702167; else goto l702170;
l702170: ;
pconverge_702169 = _681317;
goto l702168;
l702167: ;
pconverge_702169 = _701379;
goto l702168;
l702168: ;
converge_702169 = pconverge_702169;
pconverge_688276 = converge_702169;
goto l688275;
l688274: ;
pconverge_688276 = 0;
goto l688275;
l688275: ;
converge_688276 = pconverge_688276;
if (_681234) goto l688277; else goto l702161;
l702161: ;
if (_701528) goto l702162; else goto l702165;
l702165: ;
pconverge_702164 = _681233;
goto l702163;
l702162: ;
pconverge_702164 = _701347;
goto l702163;
l702163: ;
converge_702164 = pconverge_702164;
pconverge_688279 = converge_702164;
goto l688278;
l688277: ;
pconverge_688279 = 0;
goto l688278;
l688278: ;
converge_688279 = pconverge_688279;
if (_681240) goto l688280; else goto l702156;
l702156: ;
if (_701522) goto l702157; else goto l702160;
l702160: ;
pconverge_702159 = _681239;
goto l702158;
l702157: ;
pconverge_702159 = _701347;
goto l702158;
l702158: ;
converge_702159 = pconverge_702159;
pconverge_688282 = converge_702159;
goto l688281;
l688280: ;
pconverge_688282 = 0;
goto l688281;
l688281: ;
converge_688282 = pconverge_688282;
if (_681244) goto l688283; else goto l702151;
l702151: ;
if (_701516) goto l702152; else goto l702155;
l702155: ;
pconverge_702154 = xi_681232;
goto l702153;
l702152: ;
pconverge_702154 = _701347;
goto l702153;
l702153: ;
converge_702154 = pconverge_702154;
pconverge_688285 = converge_702154;
goto l688284;
l688283: ;
pconverge_688285 = 0;
goto l688284;
l688284: ;
converge_688285 = pconverge_688285;
if (_681249) goto l688286; else goto l702146;
l702146: ;
if (_701356) goto l702147; else goto l702150;
l702150: ;
pconverge_702149 = _681248;
goto l702148;
l702147: ;
pconverge_702149 = _701347;
goto l702148;
l702148: ;
converge_702149 = pconverge_702149;
pconverge_688288 = converge_702149;
goto l688287;
l688286: ;
pconverge_688288 = 0;
goto l688287;
l688287: ;
converge_688288 = pconverge_688288;
if (_681254) goto l688289; else goto l702141;
l702141: ;
if (_701350) goto l702142; else goto l702145;
l702145: ;
pconverge_702144 = _681253;
goto l702143;
l702142: ;
pconverge_702144 = _701347;
goto l702143;
l702143: ;
converge_702144 = pconverge_702144;
pconverge_688291 = converge_702144;
goto l688290;
l688289: ;
pconverge_688291 = 0;
goto l688290;
l688290: ;
converge_688291 = pconverge_688291;
if (_681511) goto l688292; else goto l702136;
l702136: ;
if (_701375) goto l702137; else goto l702140;
l702140: ;
pconverge_702139 = _681510;
goto l702138;
l702137: ;
pconverge_702139 = _701379;
goto l702138;
l702138: ;
converge_702139 = pconverge_702139;
pconverge_688294 = converge_702139;
goto l688293;
l688292: ;
pconverge_688294 = 0;
goto l688293;
l688293: ;
converge_688294 = pconverge_688294;
if (_681234) goto l688295; else goto l702131;
l702131: ;
if (_701528) goto l702132; else goto l702135;
l702135: ;
pconverge_702134 = _681233;
goto l702133;
l702132: ;
pconverge_702134 = _701347;
goto l702133;
l702133: ;
converge_702134 = pconverge_702134;
pconverge_688297 = converge_702134;
goto l688296;
l688295: ;
pconverge_688297 = 0;
goto l688296;
l688296: ;
converge_688297 = pconverge_688297;
if (_681240) goto l688298; else goto l702126;
l702126: ;
if (_701522) goto l702127; else goto l702130;
l702130: ;
pconverge_702129 = _681239;
goto l702128;
l702127: ;
pconverge_702129 = _701347;
goto l702128;
l702128: ;
converge_702129 = pconverge_702129;
pconverge_688300 = converge_702129;
goto l688299;
l688298: ;
pconverge_688300 = 0;
goto l688299;
l688299: ;
converge_688300 = pconverge_688300;
if (_681244) goto l688301; else goto l702121;
l702121: ;
if (_701516) goto l702122; else goto l702125;
l702125: ;
pconverge_702124 = xi_681232;
goto l702123;
l702122: ;
pconverge_702124 = _701347;
goto l702123;
l702123: ;
converge_702124 = pconverge_702124;
pconverge_688303 = converge_702124;
goto l688302;
l688301: ;
pconverge_688303 = 0;
goto l688302;
l688302: ;
converge_688303 = pconverge_688303;
if (_681249) goto l688304; else goto l702116;
l702116: ;
if (_701356) goto l702117; else goto l702120;
l702120: ;
pconverge_702119 = _681248;
goto l702118;
l702117: ;
pconverge_702119 = _701347;
goto l702118;
l702118: ;
converge_702119 = pconverge_702119;
pconverge_688306 = converge_702119;
goto l688305;
l688304: ;
pconverge_688306 = 0;
goto l688305;
l688305: ;
converge_688306 = pconverge_688306;
if (_681254) goto l688307; else goto l702111;
l702111: ;
if (_701350) goto l702112; else goto l702115;
l702115: ;
pconverge_702114 = _681253;
goto l702113;
l702112: ;
pconverge_702114 = _701347;
goto l702113;
l702113: ;
converge_702114 = pconverge_702114;
pconverge_688309 = converge_702114;
goto l688308;
l688307: ;
pconverge_688309 = 0;
goto l688308;
l688308: ;
converge_688309 = pconverge_688309;
if (_681435) goto l688310; else goto l702106;
l702106: ;
if (_701500) goto l702107; else goto l702110;
l702110: ;
pconverge_702109 = _681434;
goto l702108;
l702107: ;
pconverge_702109 = _701379;
goto l702108;
l702108: ;
converge_702109 = pconverge_702109;
pconverge_688312 = converge_702109;
goto l688311;
l688310: ;
pconverge_688312 = 0;
goto l688311;
l688311: ;
converge_688312 = pconverge_688312;
if (_681341) goto l688313; else goto l702101;
l702101: ;
if (_701368) goto l702102; else goto l702105;
l702105: ;
pconverge_702104 = _681340;
goto l702103;
l702102: ;
pconverge_702104 = _701347;
goto l702103;
l702103: ;
converge_702104 = pconverge_702104;
pconverge_688315 = converge_702104;
goto l688314;
l688313: ;
pconverge_688315 = 0;
goto l688314;
l688314: ;
converge_688315 = pconverge_688315;
if (_681346) goto l688316; else goto l702096;
l702096: ;
if (_701362) goto l702097; else goto l702100;
l702100: ;
pconverge_702099 = _681345;
goto l702098;
l702097: ;
pconverge_702099 = _701347;
goto l702098;
l702098: ;
converge_702099 = pconverge_702099;
pconverge_688318 = converge_702099;
goto l688317;
l688316: ;
pconverge_688318 = 0;
goto l688317;
l688317: ;
converge_688318 = pconverge_688318;
if (_681249) goto l688319; else goto l702091;
l702091: ;
if (_701356) goto l702092; else goto l702095;
l702095: ;
pconverge_702094 = _681248;
goto l702093;
l702092: ;
pconverge_702094 = _701347;
goto l702093;
l702093: ;
converge_702094 = pconverge_702094;
pconverge_688321 = converge_702094;
goto l688320;
l688319: ;
pconverge_688321 = 0;
goto l688320;
l688320: ;
converge_688321 = pconverge_688321;
if (_681254) goto l688322; else goto l702086;
l702086: ;
if (_701350) goto l702087; else goto l702090;
l702090: ;
pconverge_702089 = _681253;
goto l702088;
l702087: ;
pconverge_702089 = _701347;
goto l702088;
l702088: ;
converge_702089 = pconverge_702089;
pconverge_688324 = converge_702089;
goto l688323;
l688322: ;
pconverge_688324 = 0;
goto l688323;
l688323: ;
converge_688324 = pconverge_688324;
if (_681358) goto l688325; else goto l702081;
l702081: ;
if (_701343) goto l702082; else goto l702085;
l702085: ;
pconverge_702084 = _681357;
goto l702083;
l702082: ;
pconverge_702084 = _701347;
goto l702083;
l702083: ;
converge_702084 = pconverge_702084;
pconverge_688327 = converge_702084;
goto l688326;
l688325: ;
pconverge_688327 = 0;
goto l688326;
l688326: ;
converge_688327 = pconverge_688327;
if (_681455) goto l688328; else goto l702076;
l702076: ;
if (_701469) goto l702077; else goto l702080;
l702080: ;
pconverge_702079 = _681454;
goto l702078;
l702077: ;
pconverge_702079 = _701379;
goto l702078;
l702078: ;
converge_702079 = pconverge_702079;
pconverge_688330 = converge_702079;
goto l688329;
l688328: ;
pconverge_688330 = 0;
goto l688329;
l688329: ;
converge_688330 = pconverge_688330;
if (_681341) goto l688331; else goto l702071;
l702071: ;
if (_701368) goto l702072; else goto l702075;
l702075: ;
pconverge_702074 = _681340;
goto l702073;
l702072: ;
pconverge_702074 = _701347;
goto l702073;
l702073: ;
converge_702074 = pconverge_702074;
pconverge_688333 = converge_702074;
goto l688332;
l688331: ;
pconverge_688333 = 0;
goto l688332;
l688332: ;
converge_688333 = pconverge_688333;
if (_681346) goto l688334; else goto l702066;
l702066: ;
if (_701362) goto l702067; else goto l702070;
l702070: ;
pconverge_702069 = _681345;
goto l702068;
l702067: ;
pconverge_702069 = _701347;
goto l702068;
l702068: ;
converge_702069 = pconverge_702069;
pconverge_688336 = converge_702069;
goto l688335;
l688334: ;
pconverge_688336 = 0;
goto l688335;
l688335: ;
converge_688336 = pconverge_688336;
if (_681249) goto l688337; else goto l702061;
l702061: ;
if (_701356) goto l702062; else goto l702065;
l702065: ;
pconverge_702064 = _681248;
goto l702063;
l702062: ;
pconverge_702064 = _701347;
goto l702063;
l702063: ;
converge_702064 = pconverge_702064;
pconverge_688339 = converge_702064;
goto l688338;
l688337: ;
pconverge_688339 = 0;
goto l688338;
l688338: ;
converge_688339 = pconverge_688339;
if (_681254) goto l688340; else goto l702056;
l702056: ;
if (_701350) goto l702057; else goto l702060;
l702060: ;
pconverge_702059 = _681253;
goto l702058;
l702057: ;
pconverge_702059 = _701347;
goto l702058;
l702058: ;
converge_702059 = pconverge_702059;
pconverge_688342 = converge_702059;
goto l688341;
l688340: ;
pconverge_688342 = 0;
goto l688341;
l688341: ;
converge_688342 = pconverge_688342;
if (_681358) goto l688343; else goto l702051;
l702051: ;
if (_701343) goto l702052; else goto l702055;
l702055: ;
pconverge_702054 = _681357;
goto l702053;
l702052: ;
pconverge_702054 = _701347;
goto l702053;
l702053: ;
converge_702054 = pconverge_702054;
pconverge_688345 = converge_702054;
goto l688344;
l688343: ;
pconverge_688345 = 0;
goto l688344;
l688344: ;
converge_688345 = pconverge_688345;
if (_681298) goto l688346; else goto l702046;
l702046: ;
if (_701438) goto l702047; else goto l702050;
l702050: ;
pconverge_702049 = _681297;
goto l702048;
l702047: ;
pconverge_702049 = _701379;
goto l702048;
l702048: ;
converge_702049 = pconverge_702049;
pconverge_688348 = converge_702049;
goto l688347;
l688346: ;
pconverge_688348 = 0;
goto l688347;
l688347: ;
converge_688348 = pconverge_688348;
if (_681341) goto l688349; else goto l702041;
l702041: ;
if (_701368) goto l702042; else goto l702045;
l702045: ;
pconverge_702044 = _681340;
goto l702043;
l702042: ;
pconverge_702044 = _701347;
goto l702043;
l702043: ;
converge_702044 = pconverge_702044;
pconverge_688351 = converge_702044;
goto l688350;
l688349: ;
pconverge_688351 = 0;
goto l688350;
l688350: ;
converge_688351 = pconverge_688351;
if (_681346) goto l688352; else goto l702036;
l702036: ;
if (_701362) goto l702037; else goto l702040;
l702040: ;
pconverge_702039 = _681345;
goto l702038;
l702037: ;
pconverge_702039 = _701347;
goto l702038;
l702038: ;
converge_702039 = pconverge_702039;
pconverge_688354 = converge_702039;
goto l688353;
l688352: ;
pconverge_688354 = 0;
goto l688353;
l688353: ;
converge_688354 = pconverge_688354;
if (_681249) goto l688355; else goto l702031;
l702031: ;
if (_701356) goto l702032; else goto l702035;
l702035: ;
pconverge_702034 = _681248;
goto l702033;
l702032: ;
pconverge_702034 = _701347;
goto l702033;
l702033: ;
converge_702034 = pconverge_702034;
pconverge_688357 = converge_702034;
goto l688356;
l688355: ;
pconverge_688357 = 0;
goto l688356;
l688356: ;
converge_688357 = pconverge_688357;
if (_681254) goto l688358; else goto l702026;
l702026: ;
if (_701350) goto l702027; else goto l702030;
l702030: ;
pconverge_702029 = _681253;
goto l702028;
l702027: ;
pconverge_702029 = _701347;
goto l702028;
l702028: ;
converge_702029 = pconverge_702029;
pconverge_688360 = converge_702029;
goto l688359;
l688358: ;
pconverge_688360 = 0;
goto l688359;
l688359: ;
converge_688360 = pconverge_688360;
if (_681358) goto l688361; else goto l702021;
l702021: ;
if (_701343) goto l702022; else goto l702025;
l702025: ;
pconverge_702024 = _681357;
goto l702023;
l702022: ;
pconverge_702024 = _701347;
goto l702023;
l702023: ;
converge_702024 = pconverge_702024;
pconverge_688363 = converge_702024;
goto l688362;
l688361: ;
pconverge_688363 = 0;
goto l688362;
l688362: ;
converge_688363 = pconverge_688363;
if (_681318) goto l688364; else goto l702016;
l702016: ;
if (_701407) goto l702017; else goto l702020;
l702020: ;
pconverge_702019 = _681317;
goto l702018;
l702017: ;
pconverge_702019 = _701379;
goto l702018;
l702018: ;
converge_702019 = pconverge_702019;
pconverge_688366 = converge_702019;
goto l688365;
l688364: ;
pconverge_688366 = 0;
goto l688365;
l688365: ;
converge_688366 = pconverge_688366;
if (_681341) goto l688367; else goto l702011;
l702011: ;
if (_701368) goto l702012; else goto l702015;
l702015: ;
pconverge_702014 = _681340;
goto l702013;
l702012: ;
pconverge_702014 = _701347;
goto l702013;
l702013: ;
converge_702014 = pconverge_702014;
pconverge_688369 = converge_702014;
goto l688368;
l688367: ;
pconverge_688369 = 0;
goto l688368;
l688368: ;
converge_688369 = pconverge_688369;
if (_681346) goto l688370; else goto l702006;
l702006: ;
if (_701362) goto l702007; else goto l702010;
l702010: ;
pconverge_702009 = _681345;
goto l702008;
l702007: ;
pconverge_702009 = _701347;
goto l702008;
l702008: ;
converge_702009 = pconverge_702009;
pconverge_688372 = converge_702009;
goto l688371;
l688370: ;
pconverge_688372 = 0;
goto l688371;
l688371: ;
converge_688372 = pconverge_688372;
if (_681249) goto l688373; else goto l702001;
l702001: ;
if (_701356) goto l702002; else goto l702005;
l702005: ;
pconverge_702004 = _681248;
goto l702003;
l702002: ;
pconverge_702004 = _701347;
goto l702003;
l702003: ;
converge_702004 = pconverge_702004;
pconverge_688375 = converge_702004;
goto l688374;
l688373: ;
pconverge_688375 = 0;
goto l688374;
l688374: ;
converge_688375 = pconverge_688375;
if (_681254) goto l688376; else goto l701996;
l701996: ;
if (_701350) goto l701997; else goto l702000;
l702000: ;
pconverge_701999 = _681253;
goto l701998;
l701997: ;
pconverge_701999 = _701347;
goto l701998;
l701998: ;
converge_701999 = pconverge_701999;
pconverge_688378 = converge_701999;
goto l688377;
l688376: ;
pconverge_688378 = 0;
goto l688377;
l688377: ;
converge_688378 = pconverge_688378;
if (_681358) goto l688379; else goto l701991;
l701991: ;
if (_701343) goto l701992; else goto l701995;
l701995: ;
pconverge_701994 = _681357;
goto l701993;
l701992: ;
pconverge_701994 = _701347;
goto l701993;
l701993: ;
converge_701994 = pconverge_701994;
pconverge_688381 = converge_701994;
goto l688380;
l688379: ;
pconverge_688381 = 0;
goto l688380;
l688380: ;
converge_688381 = pconverge_688381;
if (_681511) goto l688382; else goto l701986;
l701986: ;
if (_701375) goto l701987; else goto l701990;
l701990: ;
pconverge_701989 = _681510;
goto l701988;
l701987: ;
pconverge_701989 = _701379;
goto l701988;
l701988: ;
converge_701989 = pconverge_701989;
pconverge_688384 = converge_701989;
goto l688383;
l688382: ;
pconverge_688384 = 0;
goto l688383;
l688383: ;
converge_688384 = pconverge_688384;
if (_681341) goto l688385; else goto l701981;
l701981: ;
if (_701368) goto l701982; else goto l701985;
l701985: ;
pconverge_701984 = _681340;
goto l701983;
l701982: ;
pconverge_701984 = _701347;
goto l701983;
l701983: ;
converge_701984 = pconverge_701984;
pconverge_688387 = converge_701984;
goto l688386;
l688385: ;
pconverge_688387 = 0;
goto l688386;
l688386: ;
converge_688387 = pconverge_688387;
if (_681346) goto l688388; else goto l701976;
l701976: ;
if (_701362) goto l701977; else goto l701980;
l701980: ;
pconverge_701979 = _681345;
goto l701978;
l701977: ;
pconverge_701979 = _701347;
goto l701978;
l701978: ;
converge_701979 = pconverge_701979;
pconverge_688390 = converge_701979;
goto l688389;
l688388: ;
pconverge_688390 = 0;
goto l688389;
l688389: ;
converge_688390 = pconverge_688390;
if (_681249) goto l688391; else goto l701971;
l701971: ;
if (_701356) goto l701972; else goto l701975;
l701975: ;
pconverge_701974 = _681248;
goto l701973;
l701972: ;
pconverge_701974 = _701347;
goto l701973;
l701973: ;
converge_701974 = pconverge_701974;
pconverge_688393 = converge_701974;
goto l688392;
l688391: ;
pconverge_688393 = 0;
goto l688392;
l688392: ;
converge_688393 = pconverge_688393;
if (_681254) goto l688394; else goto l701966;
l701966: ;
if (_701350) goto l701967; else goto l701970;
l701970: ;
pconverge_701969 = _681253;
goto l701968;
l701967: ;
pconverge_701969 = _701347;
goto l701968;
l701968: ;
converge_701969 = pconverge_701969;
pconverge_688396 = converge_701969;
goto l688395;
l688394: ;
pconverge_688396 = 0;
goto l688395;
l688395: ;
converge_688396 = pconverge_688396;
if (_681358) goto l688397; else goto l701961;
l701961: ;
if (_701343) goto l701962; else goto l701965;
l701965: ;
pconverge_701964 = _681357;
goto l701963;
l701962: ;
pconverge_701964 = _701347;
goto l701963;
l701963: ;
converge_701964 = pconverge_701964;
pconverge_688399 = converge_701964;
goto l688398;
l688397: ;
pconverge_688399 = 0;
goto l688398;
l688398: ;
converge_688399 = pconverge_688399;
if (_681228) goto l688400; else goto l701956;
l701956: ;
if (_701806) goto l701957; else goto l701960;
l701960: ;
pconverge_701959 = _681226;
goto l701958;
l701957: ;
pconverge_701959 = _701379;
goto l701958;
l701958: ;
converge_701959 = pconverge_701959;
pconverge_688402 = converge_701959;
goto l688401;
l688400: ;
pconverge_688402 = 0;
goto l688401;
l688401: ;
converge_688402 = pconverge_688402;
if (_681234) goto l688403; else goto l701951;
l701951: ;
if (_701528) goto l701952; else goto l701955;
l701955: ;
pconverge_701954 = _681233;
goto l701953;
l701952: ;
pconverge_701954 = _701347;
goto l701953;
l701953: ;
converge_701954 = pconverge_701954;
pconverge_688405 = converge_701954;
goto l688404;
l688403: ;
pconverge_688405 = 0;
goto l688404;
l688404: ;
converge_688405 = pconverge_688405;
if (_681240) goto l688406; else goto l701946;
l701946: ;
if (_701522) goto l701947; else goto l701950;
l701950: ;
pconverge_701949 = _681239;
goto l701948;
l701947: ;
pconverge_701949 = _701347;
goto l701948;
l701948: ;
converge_701949 = pconverge_701949;
pconverge_688408 = converge_701949;
goto l688407;
l688406: ;
pconverge_688408 = 0;
goto l688407;
l688407: ;
converge_688408 = pconverge_688408;
if (_681244) goto l688409; else goto l701941;
l701941: ;
if (_701516) goto l701942; else goto l701945;
l701945: ;
pconverge_701944 = xi_681232;
goto l701943;
l701942: ;
pconverge_701944 = _701347;
goto l701943;
l701943: ;
converge_701944 = pconverge_701944;
pconverge_688411 = converge_701944;
goto l688410;
l688409: ;
pconverge_688411 = 0;
goto l688410;
l688410: ;
converge_688411 = pconverge_688411;
if (_681249) goto l688412; else goto l701936;
l701936: ;
if (_701356) goto l701937; else goto l701940;
l701940: ;
pconverge_701939 = _681248;
goto l701938;
l701937: ;
pconverge_701939 = _701347;
goto l701938;
l701938: ;
converge_701939 = pconverge_701939;
pconverge_688414 = converge_701939;
goto l688413;
l688412: ;
pconverge_688414 = 0;
goto l688413;
l688413: ;
converge_688414 = pconverge_688414;
if (_681254) goto l688415; else goto l701931;
l701931: ;
if (_701350) goto l701932; else goto l701935;
l701935: ;
pconverge_701934 = _681253;
goto l701933;
l701932: ;
pconverge_701934 = _701347;
goto l701933;
l701933: ;
converge_701934 = pconverge_701934;
pconverge_688417 = converge_701934;
goto l688416;
l688415: ;
pconverge_688417 = 0;
goto l688416;
l688416: ;
converge_688417 = pconverge_688417;
if (_681259) goto l688418; else goto l701926;
l701926: ;
if (_701775) goto l701927; else goto l701930;
l701930: ;
pconverge_701929 = _681258;
goto l701928;
l701927: ;
pconverge_701929 = _701379;
goto l701928;
l701928: ;
converge_701929 = pconverge_701929;
pconverge_688420 = converge_701929;
goto l688419;
l688418: ;
pconverge_688420 = 0;
goto l688419;
l688419: ;
converge_688420 = pconverge_688420;
if (_681234) goto l688421; else goto l701921;
l701921: ;
if (_701528) goto l701922; else goto l701925;
l701925: ;
pconverge_701924 = _681233;
goto l701923;
l701922: ;
pconverge_701924 = _701347;
goto l701923;
l701923: ;
converge_701924 = pconverge_701924;
pconverge_688423 = converge_701924;
goto l688422;
l688421: ;
pconverge_688423 = 0;
goto l688422;
l688422: ;
converge_688423 = pconverge_688423;
if (_681240) goto l688424; else goto l701916;
l701916: ;
if (_701522) goto l701917; else goto l701920;
l701920: ;
pconverge_701919 = _681239;
goto l701918;
l701917: ;
pconverge_701919 = _701347;
goto l701918;
l701918: ;
converge_701919 = pconverge_701919;
pconverge_688426 = converge_701919;
goto l688425;
l688424: ;
pconverge_688426 = 0;
goto l688425;
l688425: ;
converge_688426 = pconverge_688426;
if (_681244) goto l688427; else goto l701911;
l701911: ;
if (_701516) goto l701912; else goto l701915;
l701915: ;
pconverge_701914 = xi_681232;
goto l701913;
l701912: ;
pconverge_701914 = _701347;
goto l701913;
l701913: ;
converge_701914 = pconverge_701914;
pconverge_688429 = converge_701914;
goto l688428;
l688427: ;
pconverge_688429 = 0;
goto l688428;
l688428: ;
converge_688429 = pconverge_688429;
if (_681249) goto l688430; else goto l701906;
l701906: ;
if (_701356) goto l701907; else goto l701910;
l701910: ;
pconverge_701909 = _681248;
goto l701908;
l701907: ;
pconverge_701909 = _701347;
goto l701908;
l701908: ;
converge_701909 = pconverge_701909;
pconverge_688432 = converge_701909;
goto l688431;
l688430: ;
pconverge_688432 = 0;
goto l688431;
l688431: ;
converge_688432 = pconverge_688432;
if (_681254) goto l688433; else goto l701901;
l701901: ;
if (_701350) goto l701902; else goto l701905;
l701905: ;
pconverge_701904 = _681253;
goto l701903;
l701902: ;
pconverge_701904 = _701347;
goto l701903;
l701903: ;
converge_701904 = pconverge_701904;
pconverge_688435 = converge_701904;
goto l688434;
l688433: ;
pconverge_688435 = 0;
goto l688434;
l688434: ;
converge_688435 = pconverge_688435;
if (_681278) goto l688436; else goto l701896;
l701896: ;
if (_701744) goto l701897; else goto l701900;
l701900: ;
pconverge_701899 = yi_681224;
goto l701898;
l701897: ;
pconverge_701899 = _701379;
goto l701898;
l701898: ;
converge_701899 = pconverge_701899;
pconverge_688438 = converge_701899;
goto l688437;
l688436: ;
pconverge_688438 = 0;
goto l688437;
l688437: ;
converge_688438 = pconverge_688438;
if (_681234) goto l688439; else goto l701891;
l701891: ;
if (_701528) goto l701892; else goto l701895;
l701895: ;
pconverge_701894 = _681233;
goto l701893;
l701892: ;
pconverge_701894 = _701347;
goto l701893;
l701893: ;
converge_701894 = pconverge_701894;
pconverge_688441 = converge_701894;
goto l688440;
l688439: ;
pconverge_688441 = 0;
goto l688440;
l688440: ;
converge_688441 = pconverge_688441;
if (_681240) goto l688442; else goto l701886;
l701886: ;
if (_701522) goto l701887; else goto l701890;
l701890: ;
pconverge_701889 = _681239;
goto l701888;
l701887: ;
pconverge_701889 = _701347;
goto l701888;
l701888: ;
converge_701889 = pconverge_701889;
pconverge_688444 = converge_701889;
goto l688443;
l688442: ;
pconverge_688444 = 0;
goto l688443;
l688443: ;
converge_688444 = pconverge_688444;
if (_681244) goto l688445; else goto l701881;
l701881: ;
if (_701516) goto l701882; else goto l701885;
l701885: ;
pconverge_701884 = xi_681232;
goto l701883;
l701882: ;
pconverge_701884 = _701347;
goto l701883;
l701883: ;
converge_701884 = pconverge_701884;
pconverge_688447 = converge_701884;
goto l688446;
l688445: ;
pconverge_688447 = 0;
goto l688446;
l688446: ;
converge_688447 = pconverge_688447;
if (_681249) goto l688448; else goto l701876;
l701876: ;
if (_701356) goto l701877; else goto l701880;
l701880: ;
pconverge_701879 = _681248;
goto l701878;
l701877: ;
pconverge_701879 = _701347;
goto l701878;
l701878: ;
converge_701879 = pconverge_701879;
pconverge_688450 = converge_701879;
goto l688449;
l688448: ;
pconverge_688450 = 0;
goto l688449;
l688449: ;
converge_688450 = pconverge_688450;
if (_681254) goto l688451; else goto l701871;
l701871: ;
if (_701350) goto l701872; else goto l701875;
l701875: ;
pconverge_701874 = _681253;
goto l701873;
l701872: ;
pconverge_701874 = _701347;
goto l701873;
l701873: ;
converge_701874 = pconverge_701874;
pconverge_688453 = converge_701874;
goto l688452;
l688451: ;
pconverge_688453 = 0;
goto l688452;
l688452: ;
converge_688453 = pconverge_688453;
if (_681298) goto l688454; else goto l701866;
l701866: ;
if (_701438) goto l701867; else goto l701870;
l701870: ;
pconverge_701869 = _681297;
goto l701868;
l701867: ;
pconverge_701869 = _701379;
goto l701868;
l701868: ;
converge_701869 = pconverge_701869;
pconverge_688456 = converge_701869;
goto l688455;
l688454: ;
pconverge_688456 = 0;
goto l688455;
l688455: ;
converge_688456 = pconverge_688456;
if (_681234) goto l688457; else goto l701861;
l701861: ;
if (_701528) goto l701862; else goto l701865;
l701865: ;
pconverge_701864 = _681233;
goto l701863;
l701862: ;
pconverge_701864 = _701347;
goto l701863;
l701863: ;
converge_701864 = pconverge_701864;
pconverge_688459 = converge_701864;
goto l688458;
l688457: ;
pconverge_688459 = 0;
goto l688458;
l688458: ;
converge_688459 = pconverge_688459;
if (_681240) goto l688460; else goto l701856;
l701856: ;
if (_701522) goto l701857; else goto l701860;
l701860: ;
pconverge_701859 = _681239;
goto l701858;
l701857: ;
pconverge_701859 = _701347;
goto l701858;
l701858: ;
converge_701859 = pconverge_701859;
pconverge_688462 = converge_701859;
goto l688461;
l688460: ;
pconverge_688462 = 0;
goto l688461;
l688461: ;
converge_688462 = pconverge_688462;
if (_681244) goto l688463; else goto l701851;
l701851: ;
if (_701516) goto l701852; else goto l701855;
l701855: ;
pconverge_701854 = xi_681232;
goto l701853;
l701852: ;
pconverge_701854 = _701347;
goto l701853;
l701853: ;
converge_701854 = pconverge_701854;
pconverge_688465 = converge_701854;
goto l688464;
l688463: ;
pconverge_688465 = 0;
goto l688464;
l688464: ;
converge_688465 = pconverge_688465;
if (_681249) goto l688466; else goto l701846;
l701846: ;
if (_701356) goto l701847; else goto l701850;
l701850: ;
pconverge_701849 = _681248;
goto l701848;
l701847: ;
pconverge_701849 = _701347;
goto l701848;
l701848: ;
converge_701849 = pconverge_701849;
pconverge_688468 = converge_701849;
goto l688467;
l688466: ;
pconverge_688468 = 0;
goto l688467;
l688467: ;
converge_688468 = pconverge_688468;
if (_681254) goto l688469; else goto l701841;
l701841: ;
if (_701350) goto l701842; else goto l701845;
l701845: ;
pconverge_701844 = _681253;
goto l701843;
l701842: ;
pconverge_701844 = _701347;
goto l701843;
l701843: ;
converge_701844 = pconverge_701844;
pconverge_688471 = converge_701844;
goto l688470;
l688469: ;
pconverge_688471 = 0;
goto l688470;
l688470: ;
converge_688471 = pconverge_688471;
if (_681318) goto l688472; else goto l701836;
l701836: ;
if (_701407) goto l701837; else goto l701840;
l701840: ;
pconverge_701839 = _681317;
goto l701838;
l701837: ;
pconverge_701839 = _701379;
goto l701838;
l701838: ;
converge_701839 = pconverge_701839;
pconverge_688474 = converge_701839;
goto l688473;
l688472: ;
pconverge_688474 = 0;
goto l688473;
l688473: ;
converge_688474 = pconverge_688474;
if (_681234) goto l688475; else goto l701831;
l701831: ;
if (_701528) goto l701832; else goto l701835;
l701835: ;
pconverge_701834 = _681233;
goto l701833;
l701832: ;
pconverge_701834 = _701347;
goto l701833;
l701833: ;
converge_701834 = pconverge_701834;
pconverge_688477 = converge_701834;
goto l688476;
l688475: ;
pconverge_688477 = 0;
goto l688476;
l688476: ;
converge_688477 = pconverge_688477;
if (_681240) goto l688478; else goto l701826;
l701826: ;
if (_701522) goto l701827; else goto l701830;
l701830: ;
pconverge_701829 = _681239;
goto l701828;
l701827: ;
pconverge_701829 = _701347;
goto l701828;
l701828: ;
converge_701829 = pconverge_701829;
pconverge_688480 = converge_701829;
goto l688479;
l688478: ;
pconverge_688480 = 0;
goto l688479;
l688479: ;
converge_688480 = pconverge_688480;
if (_681244) goto l688481; else goto l701821;
l701821: ;
if (_701516) goto l701822; else goto l701825;
l701825: ;
pconverge_701824 = xi_681232;
goto l701823;
l701822: ;
pconverge_701824 = _701347;
goto l701823;
l701823: ;
converge_701824 = pconverge_701824;
pconverge_688483 = converge_701824;
goto l688482;
l688481: ;
pconverge_688483 = 0;
goto l688482;
l688482: ;
converge_688483 = pconverge_688483;
if (_681249) goto l688484; else goto l701816;
l701816: ;
if (_701356) goto l701817; else goto l701820;
l701820: ;
pconverge_701819 = _681248;
goto l701818;
l701817: ;
pconverge_701819 = _701347;
goto l701818;
l701818: ;
converge_701819 = pconverge_701819;
pconverge_688486 = converge_701819;
goto l688485;
l688484: ;
pconverge_688486 = 0;
goto l688485;
l688485: ;
converge_688486 = pconverge_688486;
if (_681254) goto l688487; else goto l701811;
l701811: ;
if (_701350) goto l701812; else goto l701815;
l701815: ;
pconverge_701814 = _681253;
goto l701813;
l701812: ;
pconverge_701814 = _701347;
goto l701813;
l701813: ;
converge_701814 = pconverge_701814;
pconverge_688489 = converge_701814;
goto l688488;
l688487: ;
pconverge_688489 = 0;
goto l688488;
l688488: ;
converge_688489 = pconverge_688489;
if (_681228) goto l688490; else goto l701805;
l701805: ;
if (_701806) goto l701807; else goto l701810;
l701810: ;
pconverge_701809 = _681226;
goto l701808;
l701807: ;
pconverge_701809 = _701379;
goto l701808;
l701808: ;
converge_701809 = pconverge_701809;
pconverge_688492 = converge_701809;
goto l688491;
l688490: ;
pconverge_688492 = 0;
goto l688491;
l688491: ;
converge_688492 = pconverge_688492;
if (_681341) goto l688493; else goto l701800;
l701800: ;
if (_701368) goto l701801; else goto l701804;
l701804: ;
pconverge_701803 = _681340;
goto l701802;
l701801: ;
pconverge_701803 = _701347;
goto l701802;
l701802: ;
converge_701803 = pconverge_701803;
pconverge_688495 = converge_701803;
goto l688494;
l688493: ;
pconverge_688495 = 0;
goto l688494;
l688494: ;
converge_688495 = pconverge_688495;
if (_681346) goto l688496; else goto l701795;
l701795: ;
if (_701362) goto l701796; else goto l701799;
l701799: ;
pconverge_701798 = _681345;
goto l701797;
l701796: ;
pconverge_701798 = _701347;
goto l701797;
l701797: ;
converge_701798 = pconverge_701798;
pconverge_688498 = converge_701798;
goto l688497;
l688496: ;
pconverge_688498 = 0;
goto l688497;
l688497: ;
converge_688498 = pconverge_688498;
if (_681249) goto l688499; else goto l701790;
l701790: ;
if (_701356) goto l701791; else goto l701794;
l701794: ;
pconverge_701793 = _681248;
goto l701792;
l701791: ;
pconverge_701793 = _701347;
goto l701792;
l701792: ;
converge_701793 = pconverge_701793;
pconverge_688501 = converge_701793;
goto l688500;
l688499: ;
pconverge_688501 = 0;
goto l688500;
l688500: ;
converge_688501 = pconverge_688501;
if (_681254) goto l688502; else goto l701785;
l701785: ;
if (_701350) goto l701786; else goto l701789;
l701789: ;
pconverge_701788 = _681253;
goto l701787;
l701786: ;
pconverge_701788 = _701347;
goto l701787;
l701787: ;
converge_701788 = pconverge_701788;
pconverge_688504 = converge_701788;
goto l688503;
l688502: ;
pconverge_688504 = 0;
goto l688503;
l688503: ;
converge_688504 = pconverge_688504;
if (_681358) goto l688505; else goto l701780;
l701780: ;
if (_701343) goto l701781; else goto l701784;
l701784: ;
pconverge_701783 = _681357;
goto l701782;
l701781: ;
pconverge_701783 = _701347;
goto l701782;
l701782: ;
converge_701783 = pconverge_701783;
pconverge_688507 = converge_701783;
goto l688506;
l688505: ;
pconverge_688507 = 0;
goto l688506;
l688506: ;
converge_688507 = pconverge_688507;
if (_681259) goto l688508; else goto l701774;
l701774: ;
if (_701775) goto l701776; else goto l701779;
l701779: ;
pconverge_701778 = _681258;
goto l701777;
l701776: ;
pconverge_701778 = _701379;
goto l701777;
l701777: ;
converge_701778 = pconverge_701778;
pconverge_688510 = converge_701778;
goto l688509;
l688508: ;
pconverge_688510 = 0;
goto l688509;
l688509: ;
converge_688510 = pconverge_688510;
if (_681341) goto l688511; else goto l701769;
l701769: ;
if (_701368) goto l701770; else goto l701773;
l701773: ;
pconverge_701772 = _681340;
goto l701771;
l701770: ;
pconverge_701772 = _701347;
goto l701771;
l701771: ;
converge_701772 = pconverge_701772;
pconverge_688513 = converge_701772;
goto l688512;
l688511: ;
pconverge_688513 = 0;
goto l688512;
l688512: ;
converge_688513 = pconverge_688513;
if (_681346) goto l688514; else goto l701764;
l701764: ;
if (_701362) goto l701765; else goto l701768;
l701768: ;
pconverge_701767 = _681345;
goto l701766;
l701765: ;
pconverge_701767 = _701347;
goto l701766;
l701766: ;
converge_701767 = pconverge_701767;
pconverge_688516 = converge_701767;
goto l688515;
l688514: ;
pconverge_688516 = 0;
goto l688515;
l688515: ;
converge_688516 = pconverge_688516;
if (_681249) goto l688517; else goto l701759;
l701759: ;
if (_701356) goto l701760; else goto l701763;
l701763: ;
pconverge_701762 = _681248;
goto l701761;
l701760: ;
pconverge_701762 = _701347;
goto l701761;
l701761: ;
converge_701762 = pconverge_701762;
pconverge_688519 = converge_701762;
goto l688518;
l688517: ;
pconverge_688519 = 0;
goto l688518;
l688518: ;
converge_688519 = pconverge_688519;
if (_681254) goto l688520; else goto l701754;
l701754: ;
if (_701350) goto l701755; else goto l701758;
l701758: ;
pconverge_701757 = _681253;
goto l701756;
l701755: ;
pconverge_701757 = _701347;
goto l701756;
l701756: ;
converge_701757 = pconverge_701757;
pconverge_688522 = converge_701757;
goto l688521;
l688520: ;
pconverge_688522 = 0;
goto l688521;
l688521: ;
converge_688522 = pconverge_688522;
if (_681358) goto l688523; else goto l701749;
l701749: ;
if (_701343) goto l701750; else goto l701753;
l701753: ;
pconverge_701752 = _681357;
goto l701751;
l701750: ;
pconverge_701752 = _701347;
goto l701751;
l701751: ;
converge_701752 = pconverge_701752;
pconverge_688525 = converge_701752;
goto l688524;
l688523: ;
pconverge_688525 = 0;
goto l688524;
l688524: ;
converge_688525 = pconverge_688525;
if (_681278) goto l688526; else goto l701743;
l701743: ;
if (_701744) goto l701745; else goto l701748;
l701748: ;
pconverge_701747 = yi_681224;
goto l701746;
l701745: ;
pconverge_701747 = _701379;
goto l701746;
l701746: ;
converge_701747 = pconverge_701747;
pconverge_688528 = converge_701747;
goto l688527;
l688526: ;
pconverge_688528 = 0;
goto l688527;
l688527: ;
converge_688528 = pconverge_688528;
if (_681341) goto l688529; else goto l701738;
l701738: ;
if (_701368) goto l701739; else goto l701742;
l701742: ;
pconverge_701741 = _681340;
goto l701740;
l701739: ;
pconverge_701741 = _701347;
goto l701740;
l701740: ;
converge_701741 = pconverge_701741;
pconverge_688531 = converge_701741;
goto l688530;
l688529: ;
pconverge_688531 = 0;
goto l688530;
l688530: ;
converge_688531 = pconverge_688531;
if (_681346) goto l688532; else goto l701733;
l701733: ;
if (_701362) goto l701734; else goto l701737;
l701737: ;
pconverge_701736 = _681345;
goto l701735;
l701734: ;
pconverge_701736 = _701347;
goto l701735;
l701735: ;
converge_701736 = pconverge_701736;
pconverge_688534 = converge_701736;
goto l688533;
l688532: ;
pconverge_688534 = 0;
goto l688533;
l688533: ;
converge_688534 = pconverge_688534;
if (_681249) goto l688535; else goto l701728;
l701728: ;
if (_701356) goto l701729; else goto l701732;
l701732: ;
pconverge_701731 = _681248;
goto l701730;
l701729: ;
pconverge_701731 = _701347;
goto l701730;
l701730: ;
converge_701731 = pconverge_701731;
pconverge_688537 = converge_701731;
goto l688536;
l688535: ;
pconverge_688537 = 0;
goto l688536;
l688536: ;
converge_688537 = pconverge_688537;
if (_681254) goto l688538; else goto l701723;
l701723: ;
if (_701350) goto l701724; else goto l701727;
l701727: ;
pconverge_701726 = _681253;
goto l701725;
l701724: ;
pconverge_701726 = _701347;
goto l701725;
l701725: ;
converge_701726 = pconverge_701726;
pconverge_688540 = converge_701726;
goto l688539;
l688538: ;
pconverge_688540 = 0;
goto l688539;
l688539: ;
converge_688540 = pconverge_688540;
if (_681358) goto l688541; else goto l701718;
l701718: ;
if (_701343) goto l701719; else goto l701722;
l701722: ;
pconverge_701721 = _681357;
goto l701720;
l701719: ;
pconverge_701721 = _701347;
goto l701720;
l701720: ;
converge_701721 = pconverge_701721;
pconverge_688543 = converge_701721;
goto l688542;
l688541: ;
pconverge_688543 = 0;
goto l688542;
l688542: ;
converge_688543 = pconverge_688543;
if (_681298) goto l688544; else goto l701713;
l701713: ;
if (_701438) goto l701714; else goto l701717;
l701717: ;
pconverge_701716 = _681297;
goto l701715;
l701714: ;
pconverge_701716 = _701379;
goto l701715;
l701715: ;
converge_701716 = pconverge_701716;
pconverge_688546 = converge_701716;
goto l688545;
l688544: ;
pconverge_688546 = 0;
goto l688545;
l688545: ;
converge_688546 = pconverge_688546;
if (_681341) goto l688547; else goto l701708;
l701708: ;
if (_701368) goto l701709; else goto l701712;
l701712: ;
pconverge_701711 = _681340;
goto l701710;
l701709: ;
pconverge_701711 = _701347;
goto l701710;
l701710: ;
converge_701711 = pconverge_701711;
pconverge_688549 = converge_701711;
goto l688548;
l688547: ;
pconverge_688549 = 0;
goto l688548;
l688548: ;
converge_688549 = pconverge_688549;
if (_681346) goto l688550; else goto l701703;
l701703: ;
if (_701362) goto l701704; else goto l701707;
l701707: ;
pconverge_701706 = _681345;
goto l701705;
l701704: ;
pconverge_701706 = _701347;
goto l701705;
l701705: ;
converge_701706 = pconverge_701706;
pconverge_688552 = converge_701706;
goto l688551;
l688550: ;
pconverge_688552 = 0;
goto l688551;
l688551: ;
converge_688552 = pconverge_688552;
if (_681249) goto l688553; else goto l701698;
l701698: ;
if (_701356) goto l701699; else goto l701702;
l701702: ;
pconverge_701701 = _681248;
goto l701700;
l701699: ;
pconverge_701701 = _701347;
goto l701700;
l701700: ;
converge_701701 = pconverge_701701;
pconverge_688555 = converge_701701;
goto l688554;
l688553: ;
pconverge_688555 = 0;
goto l688554;
l688554: ;
converge_688555 = pconverge_688555;
if (_681254) goto l688556; else goto l701693;
l701693: ;
if (_701350) goto l701694; else goto l701697;
l701697: ;
pconverge_701696 = _681253;
goto l701695;
l701694: ;
pconverge_701696 = _701347;
goto l701695;
l701695: ;
converge_701696 = pconverge_701696;
pconverge_688558 = converge_701696;
goto l688557;
l688556: ;
pconverge_688558 = 0;
goto l688557;
l688557: ;
converge_688558 = pconverge_688558;
if (_681358) goto l688559; else goto l701688;
l701688: ;
if (_701343) goto l701689; else goto l701692;
l701692: ;
pconverge_701691 = _681357;
goto l701690;
l701689: ;
pconverge_701691 = _701347;
goto l701690;
l701690: ;
converge_701691 = pconverge_701691;
pconverge_688561 = converge_701691;
goto l688560;
l688559: ;
pconverge_688561 = 0;
goto l688560;
l688560: ;
converge_688561 = pconverge_688561;
if (_681318) goto l688562; else goto l701683;
l701683: ;
if (_701407) goto l701684; else goto l701687;
l701687: ;
pconverge_701686 = _681317;
goto l701685;
l701684: ;
pconverge_701686 = _701379;
goto l701685;
l701685: ;
converge_701686 = pconverge_701686;
pconverge_688564 = converge_701686;
goto l688563;
l688562: ;
pconverge_688564 = 0;
goto l688563;
l688563: ;
converge_688564 = pconverge_688564;
if (_681341) goto l688565; else goto l701678;
l701678: ;
if (_701368) goto l701679; else goto l701682;
l701682: ;
pconverge_701681 = _681340;
goto l701680;
l701679: ;
pconverge_701681 = _701347;
goto l701680;
l701680: ;
converge_701681 = pconverge_701681;
pconverge_688567 = converge_701681;
goto l688566;
l688565: ;
pconverge_688567 = 0;
goto l688566;
l688566: ;
converge_688567 = pconverge_688567;
if (_681346) goto l688568; else goto l701673;
l701673: ;
if (_701362) goto l701674; else goto l701677;
l701677: ;
pconverge_701676 = _681345;
goto l701675;
l701674: ;
pconverge_701676 = _701347;
goto l701675;
l701675: ;
converge_701676 = pconverge_701676;
pconverge_688570 = converge_701676;
goto l688569;
l688568: ;
pconverge_688570 = 0;
goto l688569;
l688569: ;
converge_688570 = pconverge_688570;
if (_681249) goto l688571; else goto l701668;
l701668: ;
if (_701356) goto l701669; else goto l701672;
l701672: ;
pconverge_701671 = _681248;
goto l701670;
l701669: ;
pconverge_701671 = _701347;
goto l701670;
l701670: ;
converge_701671 = pconverge_701671;
pconverge_688573 = converge_701671;
goto l688572;
l688571: ;
pconverge_688573 = 0;
goto l688572;
l688572: ;
converge_688573 = pconverge_688573;
if (_681254) goto l688574; else goto l701663;
l701663: ;
if (_701350) goto l701664; else goto l701667;
l701667: ;
pconverge_701666 = _681253;
goto l701665;
l701664: ;
pconverge_701666 = _701347;
goto l701665;
l701665: ;
converge_701666 = pconverge_701666;
pconverge_688576 = converge_701666;
goto l688575;
l688574: ;
pconverge_688576 = 0;
goto l688575;
l688575: ;
converge_688576 = pconverge_688576;
if (_681358) goto l688577; else goto l701658;
l701658: ;
if (_701343) goto l701659; else goto l701662;
l701662: ;
pconverge_701661 = _681357;
goto l701660;
l701659: ;
pconverge_701661 = _701347;
goto l701660;
l701660: ;
converge_701661 = pconverge_701661;
pconverge_688579 = converge_701661;
goto l688578;
l688577: ;
pconverge_688579 = 0;
goto l688578;
l688578: ;
converge_688579 = pconverge_688579;
if (_681435) goto l688580; else goto l701653;
l701653: ;
if (_701500) goto l701654; else goto l701657;
l701657: ;
pconverge_701656 = _681434;
goto l701655;
l701654: ;
pconverge_701656 = _701379;
goto l701655;
l701655: ;
converge_701656 = pconverge_701656;
pconverge_688582 = converge_701656;
goto l688581;
l688580: ;
pconverge_688582 = 0;
goto l688581;
l688581: ;
converge_688582 = pconverge_688582;
if (_681234) goto l688583; else goto l701648;
l701648: ;
if (_701528) goto l701649; else goto l701652;
l701652: ;
pconverge_701651 = _681233;
goto l701650;
l701649: ;
pconverge_701651 = _701347;
goto l701650;
l701650: ;
converge_701651 = pconverge_701651;
pconverge_688585 = converge_701651;
goto l688584;
l688583: ;
pconverge_688585 = 0;
goto l688584;
l688584: ;
converge_688585 = pconverge_688585;
if (_681240) goto l688586; else goto l701643;
l701643: ;
if (_701522) goto l701644; else goto l701647;
l701647: ;
pconverge_701646 = _681239;
goto l701645;
l701644: ;
pconverge_701646 = _701347;
goto l701645;
l701645: ;
converge_701646 = pconverge_701646;
pconverge_688588 = converge_701646;
goto l688587;
l688586: ;
pconverge_688588 = 0;
goto l688587;
l688587: ;
converge_688588 = pconverge_688588;
if (_681244) goto l688589; else goto l701638;
l701638: ;
if (_701516) goto l701639; else goto l701642;
l701642: ;
pconverge_701641 = xi_681232;
goto l701640;
l701639: ;
pconverge_701641 = _701347;
goto l701640;
l701640: ;
converge_701641 = pconverge_701641;
pconverge_688591 = converge_701641;
goto l688590;
l688589: ;
pconverge_688591 = 0;
goto l688590;
l688590: ;
converge_688591 = pconverge_688591;
if (_681249) goto l688592; else goto l701633;
l701633: ;
if (_701356) goto l701634; else goto l701637;
l701637: ;
pconverge_701636 = _681248;
goto l701635;
l701634: ;
pconverge_701636 = _701347;
goto l701635;
l701635: ;
converge_701636 = pconverge_701636;
pconverge_688594 = converge_701636;
goto l688593;
l688592: ;
pconverge_688594 = 0;
goto l688593;
l688593: ;
converge_688594 = pconverge_688594;
if (_681254) goto l688595; else goto l701628;
l701628: ;
if (_701350) goto l701629; else goto l701632;
l701632: ;
pconverge_701631 = _681253;
goto l701630;
l701629: ;
pconverge_701631 = _701347;
goto l701630;
l701630: ;
converge_701631 = pconverge_701631;
pconverge_688597 = converge_701631;
goto l688596;
l688595: ;
pconverge_688597 = 0;
goto l688596;
l688596: ;
converge_688597 = pconverge_688597;
if (_681455) goto l688598; else goto l701623;
l701623: ;
if (_701469) goto l701624; else goto l701627;
l701627: ;
pconverge_701626 = _681454;
goto l701625;
l701624: ;
pconverge_701626 = _701379;
goto l701625;
l701625: ;
converge_701626 = pconverge_701626;
pconverge_688600 = converge_701626;
goto l688599;
l688598: ;
pconverge_688600 = 0;
goto l688599;
l688599: ;
converge_688600 = pconverge_688600;
if (_681234) goto l688601; else goto l701618;
l701618: ;
if (_701528) goto l701619; else goto l701622;
l701622: ;
pconverge_701621 = _681233;
goto l701620;
l701619: ;
pconverge_701621 = _701347;
goto l701620;
l701620: ;
converge_701621 = pconverge_701621;
pconverge_688603 = converge_701621;
goto l688602;
l688601: ;
pconverge_688603 = 0;
goto l688602;
l688602: ;
converge_688603 = pconverge_688603;
if (_681240) goto l688604; else goto l701613;
l701613: ;
if (_701522) goto l701614; else goto l701617;
l701617: ;
pconverge_701616 = _681239;
goto l701615;
l701614: ;
pconverge_701616 = _701347;
goto l701615;
l701615: ;
converge_701616 = pconverge_701616;
pconverge_688606 = converge_701616;
goto l688605;
l688604: ;
pconverge_688606 = 0;
goto l688605;
l688605: ;
converge_688606 = pconverge_688606;
if (_681244) goto l688607; else goto l701608;
l701608: ;
if (_701516) goto l701609; else goto l701612;
l701612: ;
pconverge_701611 = xi_681232;
goto l701610;
l701609: ;
pconverge_701611 = _701347;
goto l701610;
l701610: ;
converge_701611 = pconverge_701611;
pconverge_688609 = converge_701611;
goto l688608;
l688607: ;
pconverge_688609 = 0;
goto l688608;
l688608: ;
converge_688609 = pconverge_688609;
if (_681249) goto l688610; else goto l701603;
l701603: ;
if (_701356) goto l701604; else goto l701607;
l701607: ;
pconverge_701606 = _681248;
goto l701605;
l701604: ;
pconverge_701606 = _701347;
goto l701605;
l701605: ;
converge_701606 = pconverge_701606;
pconverge_688612 = converge_701606;
goto l688611;
l688610: ;
pconverge_688612 = 0;
goto l688611;
l688611: ;
converge_688612 = pconverge_688612;
if (_681254) goto l688613; else goto l701598;
l701598: ;
if (_701350) goto l701599; else goto l701602;
l701602: ;
pconverge_701601 = _681253;
goto l701600;
l701599: ;
pconverge_701601 = _701347;
goto l701600;
l701600: ;
converge_701601 = pconverge_701601;
pconverge_688615 = converge_701601;
goto l688614;
l688613: ;
pconverge_688615 = 0;
goto l688614;
l688614: ;
converge_688615 = pconverge_688615;
if (_681298) goto l688616; else goto l701593;
l701593: ;
if (_701438) goto l701594; else goto l701597;
l701597: ;
pconverge_701596 = _681297;
goto l701595;
l701594: ;
pconverge_701596 = _701379;
goto l701595;
l701595: ;
converge_701596 = pconverge_701596;
pconverge_688618 = converge_701596;
goto l688617;
l688616: ;
pconverge_688618 = 0;
goto l688617;
l688617: ;
converge_688618 = pconverge_688618;
if (_681234) goto l688619; else goto l701588;
l701588: ;
if (_701528) goto l701589; else goto l701592;
l701592: ;
pconverge_701591 = _681233;
goto l701590;
l701589: ;
pconverge_701591 = _701347;
goto l701590;
l701590: ;
converge_701591 = pconverge_701591;
pconverge_688621 = converge_701591;
goto l688620;
l688619: ;
pconverge_688621 = 0;
goto l688620;
l688620: ;
converge_688621 = pconverge_688621;
if (_681240) goto l688622; else goto l701583;
l701583: ;
if (_701522) goto l701584; else goto l701587;
l701587: ;
pconverge_701586 = _681239;
goto l701585;
l701584: ;
pconverge_701586 = _701347;
goto l701585;
l701585: ;
converge_701586 = pconverge_701586;
pconverge_688624 = converge_701586;
goto l688623;
l688622: ;
pconverge_688624 = 0;
goto l688623;
l688623: ;
converge_688624 = pconverge_688624;
if (_681244) goto l688625; else goto l701578;
l701578: ;
if (_701516) goto l701579; else goto l701582;
l701582: ;
pconverge_701581 = xi_681232;
goto l701580;
l701579: ;
pconverge_701581 = _701347;
goto l701580;
l701580: ;
converge_701581 = pconverge_701581;
pconverge_688627 = converge_701581;
goto l688626;
l688625: ;
pconverge_688627 = 0;
goto l688626;
l688626: ;
converge_688627 = pconverge_688627;
if (_681249) goto l688628; else goto l701573;
l701573: ;
if (_701356) goto l701574; else goto l701577;
l701577: ;
pconverge_701576 = _681248;
goto l701575;
l701574: ;
pconverge_701576 = _701347;
goto l701575;
l701575: ;
converge_701576 = pconverge_701576;
pconverge_688630 = converge_701576;
goto l688629;
l688628: ;
pconverge_688630 = 0;
goto l688629;
l688629: ;
converge_688630 = pconverge_688630;
if (_681254) goto l688631; else goto l701568;
l701568: ;
if (_701350) goto l701569; else goto l701572;
l701572: ;
pconverge_701571 = _681253;
goto l701570;
l701569: ;
pconverge_701571 = _701347;
goto l701570;
l701570: ;
converge_701571 = pconverge_701571;
pconverge_688633 = converge_701571;
goto l688632;
l688631: ;
pconverge_688633 = 0;
goto l688632;
l688632: ;
converge_688633 = pconverge_688633;
if (_681318) goto l688634; else goto l701563;
l701563: ;
if (_701407) goto l701564; else goto l701567;
l701567: ;
pconverge_701566 = _681317;
goto l701565;
l701564: ;
pconverge_701566 = _701379;
goto l701565;
l701565: ;
converge_701566 = pconverge_701566;
pconverge_688636 = converge_701566;
goto l688635;
l688634: ;
pconverge_688636 = 0;
goto l688635;
l688635: ;
converge_688636 = pconverge_688636;
if (_681234) goto l688637; else goto l701558;
l701558: ;
if (_701528) goto l701559; else goto l701562;
l701562: ;
pconverge_701561 = _681233;
goto l701560;
l701559: ;
pconverge_701561 = _701347;
goto l701560;
l701560: ;
converge_701561 = pconverge_701561;
pconverge_688639 = converge_701561;
goto l688638;
l688637: ;
pconverge_688639 = 0;
goto l688638;
l688638: ;
converge_688639 = pconverge_688639;
if (_681240) goto l688640; else goto l701553;
l701553: ;
if (_701522) goto l701554; else goto l701557;
l701557: ;
pconverge_701556 = _681239;
goto l701555;
l701554: ;
pconverge_701556 = _701347;
goto l701555;
l701555: ;
converge_701556 = pconverge_701556;
pconverge_688642 = converge_701556;
goto l688641;
l688640: ;
pconverge_688642 = 0;
goto l688641;
l688641: ;
converge_688642 = pconverge_688642;
if (_681244) goto l688643; else goto l701548;
l701548: ;
if (_701516) goto l701549; else goto l701552;
l701552: ;
pconverge_701551 = xi_681232;
goto l701550;
l701549: ;
pconverge_701551 = _701347;
goto l701550;
l701550: ;
converge_701551 = pconverge_701551;
pconverge_688645 = converge_701551;
goto l688644;
l688643: ;
pconverge_688645 = 0;
goto l688644;
l688644: ;
converge_688645 = pconverge_688645;
if (_681249) goto l688646; else goto l701543;
l701543: ;
if (_701356) goto l701544; else goto l701547;
l701547: ;
pconverge_701546 = _681248;
goto l701545;
l701544: ;
pconverge_701546 = _701347;
goto l701545;
l701545: ;
converge_701546 = pconverge_701546;
pconverge_688648 = converge_701546;
goto l688647;
l688646: ;
pconverge_688648 = 0;
goto l688647;
l688647: ;
converge_688648 = pconverge_688648;
if (_681254) goto l688649; else goto l701538;
l701538: ;
if (_701350) goto l701539; else goto l701542;
l701542: ;
pconverge_701541 = _681253;
goto l701540;
l701539: ;
pconverge_701541 = _701347;
goto l701540;
l701540: ;
converge_701541 = pconverge_701541;
pconverge_688651 = converge_701541;
goto l688650;
l688649: ;
pconverge_688651 = 0;
goto l688650;
l688650: ;
converge_688651 = pconverge_688651;
if (_681511) goto l688652; else goto l701533;
l701533: ;
if (_701375) goto l701534; else goto l701537;
l701537: ;
pconverge_701536 = _681510;
goto l701535;
l701534: ;
pconverge_701536 = _701379;
goto l701535;
l701535: ;
converge_701536 = pconverge_701536;
pconverge_688654 = converge_701536;
goto l688653;
l688652: ;
pconverge_688654 = 0;
goto l688653;
l688653: ;
converge_688654 = pconverge_688654;
if (_681234) goto l688655; else goto l701527;
l701527: ;
if (_701528) goto l701529; else goto l701532;
l701532: ;
pconverge_701531 = _681233;
goto l701530;
l701529: ;
pconverge_701531 = _701347;
goto l701530;
l701530: ;
converge_701531 = pconverge_701531;
pconverge_688657 = converge_701531;
goto l688656;
l688655: ;
pconverge_688657 = 0;
goto l688656;
l688656: ;
converge_688657 = pconverge_688657;
if (_681240) goto l688658; else goto l701521;
l701521: ;
if (_701522) goto l701523; else goto l701526;
l701526: ;
pconverge_701525 = _681239;
goto l701524;
l701523: ;
pconverge_701525 = _701347;
goto l701524;
l701524: ;
converge_701525 = pconverge_701525;
pconverge_688660 = converge_701525;
goto l688659;
l688658: ;
pconverge_688660 = 0;
goto l688659;
l688659: ;
converge_688660 = pconverge_688660;
if (_681244) goto l688661; else goto l701515;
l701515: ;
if (_701516) goto l701517; else goto l701520;
l701520: ;
pconverge_701519 = xi_681232;
goto l701518;
l701517: ;
pconverge_701519 = _701347;
goto l701518;
l701518: ;
converge_701519 = pconverge_701519;
pconverge_688663 = converge_701519;
goto l688662;
l688661: ;
pconverge_688663 = 0;
goto l688662;
l688662: ;
converge_688663 = pconverge_688663;
if (_681249) goto l688664; else goto l701510;
l701510: ;
if (_701356) goto l701511; else goto l701514;
l701514: ;
pconverge_701513 = _681248;
goto l701512;
l701511: ;
pconverge_701513 = _701347;
goto l701512;
l701512: ;
converge_701513 = pconverge_701513;
pconverge_688666 = converge_701513;
goto l688665;
l688664: ;
pconverge_688666 = 0;
goto l688665;
l688665: ;
converge_688666 = pconverge_688666;
if (_681254) goto l688667; else goto l701505;
l701505: ;
if (_701350) goto l701506; else goto l701509;
l701509: ;
pconverge_701508 = _681253;
goto l701507;
l701506: ;
pconverge_701508 = _701347;
goto l701507;
l701507: ;
converge_701508 = pconverge_701508;
pconverge_688669 = converge_701508;
goto l688668;
l688667: ;
pconverge_688669 = 0;
goto l688668;
l688668: ;
converge_688669 = pconverge_688669;
if (_681435) goto l688670; else goto l701499;
l701499: ;
if (_701500) goto l701501; else goto l701504;
l701504: ;
pconverge_701503 = _681434;
goto l701502;
l701501: ;
pconverge_701503 = _701379;
goto l701502;
l701502: ;
converge_701503 = pconverge_701503;
pconverge_688672 = converge_701503;
goto l688671;
l688670: ;
pconverge_688672 = 0;
goto l688671;
l688671: ;
converge_688672 = pconverge_688672;
if (_681341) goto l688673; else goto l701494;
l701494: ;
if (_701368) goto l701495; else goto l701498;
l701498: ;
pconverge_701497 = _681340;
goto l701496;
l701495: ;
pconverge_701497 = _701347;
goto l701496;
l701496: ;
converge_701497 = pconverge_701497;
pconverge_688675 = converge_701497;
goto l688674;
l688673: ;
pconverge_688675 = 0;
goto l688674;
l688674: ;
converge_688675 = pconverge_688675;
if (_681346) goto l688676; else goto l701489;
l701489: ;
if (_701362) goto l701490; else goto l701493;
l701493: ;
pconverge_701492 = _681345;
goto l701491;
l701490: ;
pconverge_701492 = _701347;
goto l701491;
l701491: ;
converge_701492 = pconverge_701492;
pconverge_688678 = converge_701492;
goto l688677;
l688676: ;
pconverge_688678 = 0;
goto l688677;
l688677: ;
converge_688678 = pconverge_688678;
if (_681249) goto l688679; else goto l701484;
l701484: ;
if (_701356) goto l701485; else goto l701488;
l701488: ;
pconverge_701487 = _681248;
goto l701486;
l701485: ;
pconverge_701487 = _701347;
goto l701486;
l701486: ;
converge_701487 = pconverge_701487;
pconverge_688681 = converge_701487;
goto l688680;
l688679: ;
pconverge_688681 = 0;
goto l688680;
l688680: ;
converge_688681 = pconverge_688681;
if (_681254) goto l688682; else goto l701479;
l701479: ;
if (_701350) goto l701480; else goto l701483;
l701483: ;
pconverge_701482 = _681253;
goto l701481;
l701480: ;
pconverge_701482 = _701347;
goto l701481;
l701481: ;
converge_701482 = pconverge_701482;
pconverge_688684 = converge_701482;
goto l688683;
l688682: ;
pconverge_688684 = 0;
goto l688683;
l688683: ;
converge_688684 = pconverge_688684;
if (_681358) goto l688685; else goto l701474;
l701474: ;
if (_701343) goto l701475; else goto l701478;
l701478: ;
pconverge_701477 = _681357;
goto l701476;
l701475: ;
pconverge_701477 = _701347;
goto l701476;
l701476: ;
converge_701477 = pconverge_701477;
pconverge_688687 = converge_701477;
goto l688686;
l688685: ;
pconverge_688687 = 0;
goto l688686;
l688686: ;
converge_688687 = pconverge_688687;
if (_681455) goto l688688; else goto l701468;
l701468: ;
if (_701469) goto l701470; else goto l701473;
l701473: ;
pconverge_701472 = _681454;
goto l701471;
l701470: ;
pconverge_701472 = _701379;
goto l701471;
l701471: ;
converge_701472 = pconverge_701472;
pconverge_688690 = converge_701472;
goto l688689;
l688688: ;
pconverge_688690 = 0;
goto l688689;
l688689: ;
converge_688690 = pconverge_688690;
if (_681341) goto l688691; else goto l701463;
l701463: ;
if (_701368) goto l701464; else goto l701467;
l701467: ;
pconverge_701466 = _681340;
goto l701465;
l701464: ;
pconverge_701466 = _701347;
goto l701465;
l701465: ;
converge_701466 = pconverge_701466;
pconverge_688693 = converge_701466;
goto l688692;
l688691: ;
pconverge_688693 = 0;
goto l688692;
l688692: ;
converge_688693 = pconverge_688693;
if (_681346) goto l688694; else goto l701458;
l701458: ;
if (_701362) goto l701459; else goto l701462;
l701462: ;
pconverge_701461 = _681345;
goto l701460;
l701459: ;
pconverge_701461 = _701347;
goto l701460;
l701460: ;
converge_701461 = pconverge_701461;
pconverge_688696 = converge_701461;
goto l688695;
l688694: ;
pconverge_688696 = 0;
goto l688695;
l688695: ;
converge_688696 = pconverge_688696;
if (_681249) goto l688697; else goto l701453;
l701453: ;
if (_701356) goto l701454; else goto l701457;
l701457: ;
pconverge_701456 = _681248;
goto l701455;
l701454: ;
pconverge_701456 = _701347;
goto l701455;
l701455: ;
converge_701456 = pconverge_701456;
pconverge_688699 = converge_701456;
goto l688698;
l688697: ;
pconverge_688699 = 0;
goto l688698;
l688698: ;
converge_688699 = pconverge_688699;
if (_681254) goto l688700; else goto l701448;
l701448: ;
if (_701350) goto l701449; else goto l701452;
l701452: ;
pconverge_701451 = _681253;
goto l701450;
l701449: ;
pconverge_701451 = _701347;
goto l701450;
l701450: ;
converge_701451 = pconverge_701451;
pconverge_688702 = converge_701451;
goto l688701;
l688700: ;
pconverge_688702 = 0;
goto l688701;
l688701: ;
converge_688702 = pconverge_688702;
if (_681358) goto l688703; else goto l701443;
l701443: ;
if (_701343) goto l701444; else goto l701447;
l701447: ;
pconverge_701446 = _681357;
goto l701445;
l701444: ;
pconverge_701446 = _701347;
goto l701445;
l701445: ;
converge_701446 = pconverge_701446;
pconverge_688705 = converge_701446;
goto l688704;
l688703: ;
pconverge_688705 = 0;
goto l688704;
l688704: ;
converge_688705 = pconverge_688705;
if (_681298) goto l688706; else goto l701437;
l701437: ;
if (_701438) goto l701439; else goto l701442;
l701442: ;
pconverge_701441 = _681297;
goto l701440;
l701439: ;
pconverge_701441 = _701379;
goto l701440;
l701440: ;
converge_701441 = pconverge_701441;
pconverge_688708 = converge_701441;
goto l688707;
l688706: ;
pconverge_688708 = 0;
goto l688707;
l688707: ;
converge_688708 = pconverge_688708;
if (_681341) goto l688709; else goto l701432;
l701432: ;
if (_701368) goto l701433; else goto l701436;
l701436: ;
pconverge_701435 = _681340;
goto l701434;
l701433: ;
pconverge_701435 = _701347;
goto l701434;
l701434: ;
converge_701435 = pconverge_701435;
pconverge_688711 = converge_701435;
goto l688710;
l688709: ;
pconverge_688711 = 0;
goto l688710;
l688710: ;
converge_688711 = pconverge_688711;
if (_681346) goto l688712; else goto l701427;
l701427: ;
if (_701362) goto l701428; else goto l701431;
l701431: ;
pconverge_701430 = _681345;
goto l701429;
l701428: ;
pconverge_701430 = _701347;
goto l701429;
l701429: ;
converge_701430 = pconverge_701430;
pconverge_688714 = converge_701430;
goto l688713;
l688712: ;
pconverge_688714 = 0;
goto l688713;
l688713: ;
converge_688714 = pconverge_688714;
if (_681249) goto l688715; else goto l701422;
l701422: ;
if (_701356) goto l701423; else goto l701426;
l701426: ;
pconverge_701425 = _681248;
goto l701424;
l701423: ;
pconverge_701425 = _701347;
goto l701424;
l701424: ;
converge_701425 = pconverge_701425;
pconverge_688717 = converge_701425;
goto l688716;
l688715: ;
pconverge_688717 = 0;
goto l688716;
l688716: ;
converge_688717 = pconverge_688717;
if (_681254) goto l688718; else goto l701417;
l701417: ;
if (_701350) goto l701418; else goto l701421;
l701421: ;
pconverge_701420 = _681253;
goto l701419;
l701418: ;
pconverge_701420 = _701347;
goto l701419;
l701419: ;
converge_701420 = pconverge_701420;
pconverge_688720 = converge_701420;
goto l688719;
l688718: ;
pconverge_688720 = 0;
goto l688719;
l688719: ;
converge_688720 = pconverge_688720;
if (_681358) goto l688721; else goto l701412;
l701412: ;
if (_701343) goto l701413; else goto l701416;
l701416: ;
pconverge_701415 = _681357;
goto l701414;
l701413: ;
pconverge_701415 = _701347;
goto l701414;
l701414: ;
converge_701415 = pconverge_701415;
pconverge_688723 = converge_701415;
goto l688722;
l688721: ;
pconverge_688723 = 0;
goto l688722;
l688722: ;
converge_688723 = pconverge_688723;
if (_681318) goto l688724; else goto l701406;
l701406: ;
if (_701407) goto l701408; else goto l701411;
l701411: ;
pconverge_701410 = _681317;
goto l701409;
l701408: ;
pconverge_701410 = _701379;
goto l701409;
l701409: ;
converge_701410 = pconverge_701410;
pconverge_688726 = converge_701410;
goto l688725;
l688724: ;
pconverge_688726 = 0;
goto l688725;
l688725: ;
converge_688726 = pconverge_688726;
if (_681341) goto l688727; else goto l701401;
l701401: ;
if (_701368) goto l701402; else goto l701405;
l701405: ;
pconverge_701404 = _681340;
goto l701403;
l701402: ;
pconverge_701404 = _701347;
goto l701403;
l701403: ;
converge_701404 = pconverge_701404;
pconverge_688729 = converge_701404;
goto l688728;
l688727: ;
pconverge_688729 = 0;
goto l688728;
l688728: ;
converge_688729 = pconverge_688729;
if (_681346) goto l688730; else goto l701396;
l701396: ;
if (_701362) goto l701397; else goto l701400;
l701400: ;
pconverge_701399 = _681345;
goto l701398;
l701397: ;
pconverge_701399 = _701347;
goto l701398;
l701398: ;
converge_701399 = pconverge_701399;
pconverge_688732 = converge_701399;
goto l688731;
l688730: ;
pconverge_688732 = 0;
goto l688731;
l688731: ;
converge_688732 = pconverge_688732;
if (_681249) goto l688733; else goto l701391;
l701391: ;
if (_701356) goto l701392; else goto l701395;
l701395: ;
pconverge_701394 = _681248;
goto l701393;
l701392: ;
pconverge_701394 = _701347;
goto l701393;
l701393: ;
converge_701394 = pconverge_701394;
pconverge_688735 = converge_701394;
goto l688734;
l688733: ;
pconverge_688735 = 0;
goto l688734;
l688734: ;
converge_688735 = pconverge_688735;
if (_681254) goto l688736; else goto l701386;
l701386: ;
if (_701350) goto l701387; else goto l701390;
l701390: ;
pconverge_701389 = _681253;
goto l701388;
l701387: ;
pconverge_701389 = _701347;
goto l701388;
l701388: ;
converge_701389 = pconverge_701389;
pconverge_688738 = converge_701389;
goto l688737;
l688736: ;
pconverge_688738 = 0;
goto l688737;
l688737: ;
converge_688738 = pconverge_688738;
if (_681358) goto l688739; else goto l701381;
l701381: ;
if (_701343) goto l701382; else goto l701385;
l701385: ;
pconverge_701384 = _681357;
goto l701383;
l701382: ;
pconverge_701384 = _701347;
goto l701383;
l701383: ;
converge_701384 = pconverge_701384;
pconverge_688741 = converge_701384;
goto l688740;
l688739: ;
pconverge_688741 = 0;
goto l688740;
l688740: ;
converge_688741 = pconverge_688741;
if (_681511) goto l688742; else goto l701373;
l701373: ;
if (_701375) goto l701376; else goto l701380;
l701380: ;
pconverge_701378 = _681510;
goto l701377;
l701376: ;
pconverge_701378 = _701379;
goto l701377;
l701377: ;
converge_701378 = pconverge_701378;
pconverge_688744 = converge_701378;
goto l688743;
l688742: ;
pconverge_688744 = 0;
goto l688743;
l688743: ;
converge_688744 = pconverge_688744;
if (_681341) goto l688745; else goto l701367;
l701367: ;
if (_701368) goto l701369; else goto l701372;
l701372: ;
pconverge_701371 = _681340;
goto l701370;
l701369: ;
pconverge_701371 = _701347;
goto l701370;
l701370: ;
converge_701371 = pconverge_701371;
pconverge_688747 = converge_701371;
goto l688746;
l688745: ;
pconverge_688747 = 0;
goto l688746;
l688746: ;
converge_688747 = pconverge_688747;
if (_681346) goto l688748; else goto l701361;
l701361: ;
if (_701362) goto l701363; else goto l701366;
l701366: ;
pconverge_701365 = _681345;
goto l701364;
l701363: ;
pconverge_701365 = _701347;
goto l701364;
l701364: ;
converge_701365 = pconverge_701365;
pconverge_688750 = converge_701365;
goto l688749;
l688748: ;
pconverge_688750 = 0;
goto l688749;
l688749: ;
converge_688750 = pconverge_688750;
if (_681249) goto l688751; else goto l701355;
l701355: ;
if (_701356) goto l701357; else goto l701360;
l701360: ;
pconverge_701359 = _681248;
goto l701358;
l701357: ;
pconverge_701359 = _701347;
goto l701358;
l701358: ;
converge_701359 = pconverge_701359;
pconverge_688753 = converge_701359;
goto l688752;
l688751: ;
pconverge_688753 = 0;
goto l688752;
l688752: ;
converge_688753 = pconverge_688753;
if (_681254) goto l688754; else goto l701349;
l701349: ;
if (_701350) goto l701351; else goto l701354;
l701354: ;
pconverge_701353 = _681253;
goto l701352;
l701351: ;
pconverge_701353 = _701347;
goto l701352;
l701352: ;
converge_701353 = pconverge_701353;
pconverge_688756 = converge_701353;
goto l688755;
l688754: ;
pconverge_688756 = 0;
goto l688755;
l688755: ;
converge_688756 = pconverge_688756;
if (_681358) goto l688757; else goto l701342;
l701342: ;
if (_701343) goto l701344; else goto l701348;
l701348: ;
pconverge_701346 = _681357;
goto l701345;
l701344: ;
pconverge_701346 = _701347;
goto l701345;
l701345: ;
converge_701346 = pconverge_701346;
pconverge_688759 = converge_701346;
goto l688758;
l688757: ;
pconverge_688759 = 0;
goto l688758;
l688758: ;
converge_688759 = pconverge_688759;
float _698340;
_698340 = _687533;
float _698116;
_698116 = _687036;
float _696558;
_696558 = _683614;
float _697982;
_697982 = _686742;
float _696677;
_696677 = _683881;
float _696020;
_696020 = _682436;
float _697315;
_697315 = _685279;
float _696884;
_696884 = _684334;
float _696028;
_696028 = _682450;
float _696922;
_696922 = _684419;
float _698533;
_698533 = _687956;
float _695985;
_695985 = _682359;
float _696335;
_696335 = _683131;
float _697762;
_697762 = _686265;
float _696840;
_696840 = _684237;
float _697175;
_697175 = _684973;
float _695971;
_695971 = _682329;
float _696849;
_696849 = _684253;
float _698387;
_698387 = _687635;
float _697594;
_697594 = _685888;
float _698394;
_698394 = _687648;
float _697482;
_697482 = _685642;
float _696801;
_696801 = _684153;
float _697251;
_697251 = _685133;
float _696771;
_696771 = _684086;
float _698492;
_698492 = _687865;
float _695845;
_695845 = _682049;
float _697978;
_697978 = _686734;
float _696918;
_696918 = _684404;
float _698148;
_698148 = _687104;
float _697519;
_697519 = _685727;
float _696777;
_696777 = _684097;
float _696246;
_696246 = _682939;
float _697059;
_697059 = _684715;
float _697413;
_697413 = _685491;
int _693520;
_693520 = converge_688528 * gwidth_681983;
int _689645;
_689645 = converge_688132 * gwidth_681983;
float _697432;
_697432 = _685534;
float _696504;
_696504 = _683498;
float _696328;
_696328 = _683114;
float _697831;
_697831 = _686416;
float _697684;
_697684 = _686090;
float _697322;
_697322 = _685292;
float _696832;
_696832 = _684218;
float _696259;
_696259 = _682963;
float _696772;
_696772 = 4.000000e+00f * _696771;
float _695891;
_695891 = _682154;
float _698470;
_698470 = _687816;
float _696210;
_696210 = _682854;
float _697155;
_697155 = _684932;
float _698003;
_698003 = _686789;
float _697446;
_697446 = _685564;
float _696384;
_696384 = _683241;
float _696619;
_696619 = _683754;
float _697099;
_697099 = _684805;
float _696490;
_696490 = _683468;
float _696302;
_696302 = _683054;
int _690349;
_690349 = converge_688204 * gwidth_681983;
float _697294;
_697294 = _685232;
float _696202;
_696202 = _682834;
float _696237;
_696237 = _682915;
float _696663;
_696663 = _683851;
float _698075;
_698075 = _686945;
float _697807;
_697807 = _686361;
float _696552;
_696552 = _683603;
float _695827;
_695827 = _682008;
float _698528;
_698528 = _687942;
float _696786;
_696786 = _684117;
float _696314;
_696314 = _683084;
float _697943;
_697943 = _686651;
float _698329;
_698329 = _687509;
float _698444;
_698444 = _687756;
float _696363;
_696363 = _683191;
float _696843;
_696843 = _684243;
float _698341;
_698341 = 4.000000e+00f * _698340;
float _696104;
_696104 = _682618;
float _695948;
_695948 = _682280;
float _697248;
_697248 = _685128;
float _696648;
_696648 = _683815;
float _696371;
_696371 = _683205;
float _698339;
_698339 = _687527;
float _698058;
_698058 = _686910;
float _697992;
_697992 = _686764;
float _696533;
_696533 = _683559;
float _698450;
_698450 = _687775;
float _697560;
_697560 = _685818;
float _696357;
_696357 = _683180;
float _696812;
_696812 = _684177;
float _697169;
_697169 = _684962;
float _697834;
_697834 = _686422;
float _697217;
_697217 = _685063;
float _697086;
_697086 = _684781;
float _697591;
_697591 = _685883;
int _690420;
_690420 = _690349 + converge_688213;
float _696069;
_696069 = _682546;
float _697865;
_697865 = _686487;
float _696521;
_696521 = _683529;
float _697890;
_697890 = _686537;
float _697491;
_697491 = _685667;
float _696701;
_696701 = _683929;
float _696925;
_696925 = _684425;
float _698299;
_698299 = _687437;
float _697561;
_697561 = 6.000000e+00f * _697560;
float _695902;
_695902 = _682178;
float _695920;
_695920 = _682220;
float _696885;
_696885 = 6.000000e+00f * _696884;
float _697612;
_697612 = _685933;
float _697439;
_697439 = _685551;
float _696898;
_696898 = _684364;
float _698539;
_698539 = _687967;
float _697799;
_697799 = _686341;
float _695992;
_695992 = _682376;
float _698134;
_698134 = _687074;
float _697069;
_697069 = _684737;
float _697804;
_697804 = _686355;
float _697947;
_697947 = _686663;
float _695923;
_695923 = _682225;
int _695817;
_695817 = _681212 % 8;
float _697488;
_697488 = _685661;
float _698553;
_698553 = _687997;
float _697095;
_697095 = _684797;
float _697290;
_697290 = _685224;
float _696044;
_696044 = _682492;
float _698560;
_698560 = _688010;
float _698164;
_698164 = _687141;
float _696880;
_696880 = _684322;
float _697470;
_697470 = _685616;
float _696854;
_696854 = _684262;
float _697713;
_697713 = _686155;
float _695809;
_695809 = (float)zi_681989;
float _698095;
_698095 = _686990;
float _696332;
_696332 = _683126;
float _698259;
_698259 = _687352;
float _697768;
_697768 = _686276;
float _698089;
_698089 = _686975;
float _697436;
_697436 = _685546;
float _697363;
_697363 = _685383;
int _692816;
_692816 = converge_688456 * gwidth_681983;
float _698415;
_698415 = _687695;
float _698498;
_698498 = _687876;
float _697384;
_697384 = _685430;
float _698149;
_698149 = _687110;
float _696708;
_696708 = _683946;
float _697533;
_697533 = _685757;
float _697599;
_697599 = _685902;
float _697716;
_697716 = _686160;
int _690490;
_690490 = _690349 + converge_688219;
float _698372;
_698372 = _687600;
float _697479;
_697479 = _685637;
float _696979;
_696979 = _684545;
float _695828;
_695828 = 6.000000e+00f * _695827;
int _689786;
_689786 = _689645 + converge_688147;
float _695978;
_695978 = _682346;
float _697245;
_697245 = _685123;
float _697063;
_697063 = _684727;
float _696582;
_696582 = _683670;
float _696735;
_696735 = _684007;
float _697492;
_697492 = 6.000000e+00f * _697491;
float _697269;
_697269 = _685178;
float _698306;
_698306 = _687454;
float _697023;
_697023 = _684641;
float _696555;
_696555 = _683609;
float _698536;
_698536 = _687962;
float _697078;
_697078 = _684762;
int _691053;
_691053 = converge_688276 * gwidth_681983;
float _696473;
_696473 = _683433;
float _698296;
_698296 = _687428;
float _696649;
_696649 = 4.000000e+00f * _696648;
float _697796;
_697796 = _686336;
float _696075;
_696075 = _682557;
float _696338;
_696338 = _683136;
float _696358;
_696358 = 4.000000e+00f * _696357;
float _697460;
_697460 = _685594;
float _698265;
_698265 = _687363;
float _696591;
_696591 = _683694;
float _696792;
_696792 = _684128;
float _697359;
_697359 = _685375;
float _698449;
_698449 = _687769;
float _696240;
_696240 = _682920;
float _697461;
_697461 = _685600;
float _695995;
_695995 = _682381;
float _696815;
_696815 = _684183;
float _696763;
_696763 = _684067;
float _695966;
_695966 = _682316;
float _698546;
_698546 = _687980;
float _696752;
_696752 = _684042;
float _696101;
_696101 = _682613;
float _698342;
_698342 = _698339 + _698341;
float _697989;
_697989 = _686759;
float _696450;
_696450 = _683378;
float _696674;
_696674 = _683875;
float _696951;
_696951 = _684485;
int _695456;
_695456 = converge_688726 * gwidth_681983;
float _697464;
_697464 = _685606;
float _698061;
_698061 = _686915;
float _697378;
_697378 = _685419;
float _695909;
_695909 = _682195;
float _695930;
_695930 = _682238;
float _696318;
_696318 = _683096;
float _698309;
_698309 = _687459;
float _695821;
_695821 = _681995;
int _689293;
_689293 = converge_688096 * gwidth_681983;
int _689469;
_689469 = converge_688114 * gwidth_681983;
float _697172;
_697172 = _684968;
float _697680;
_697680 = _686078;
float _696378;
_696378 = _683222;
float _695989;
_695989 = _682371;
float _697419;
_697419 = _685510;
float _697571;
_697571 = _685842;
float _697114;
_697114 = _684841;
float _696227;
_696227 = _682889;
float _696113;
_696113 = _682643;
float _697956;
_697956 = _686682;
float _697395;
_697395 = _685455;
float _697211;
_697211 = _685043;
int _689997;
_689997 = converge_688168 * gwidth_681983;
float _696618;
_696618 = _683748;
float _698437;
_698437 = _687739;
float _696185;
_696185 = _682799;
float _698072;
_698072 = _686940;
float _696547;
_696547 = _683589;
float _698052;
_698052 = _686899;
float _698170;
_698170 = _687152;
float _696487;
_696487 = _683463;
float _698152;
_698152 = _687116;
float _697364;
_697364 = _685389;
float _695959;
_695959 = _682299;
float _697618;
_697618 = _685944;
int _693168;
_693168 = converge_688492 * gwidth_681983;
float _696038;
_696038 = _682472;
int _688941;
_688941 = converge_688060 * gwidth_681983;
float _697087;
_697087 = 4.000000e+00f * _697086;
float _695944;
_695944 = _682268;
float _698051;
_698051 = _686893;
float _698010;
_698010 = _686802;
float _696578;
_696578 = _683658;
float _697741;
_697741 = _686215;
float _698412;
_698412 = _687690;
float _696697;
_696697 = _683921;
float _698349;
_698349 = _687549;
float _698554;
_698554 = 4.000000e+00f * _698553;
float _697911;
_697911 = _686583;
float _697902;
_697902 = _686567;
float _696789;
_696789 = _684123;
float _696909;
_696909 = _684388;
float _696770;
_696770 = _684080;
float _696196;
_696196 = _682824;
float _696961;
_696961 = _684503;
float _696717;
_696717 = _683966;
float _696083;
_696083 = _682576;
float _698506;
_698506 = _687890;
float _695917;
_695917 = _682214;
int _689998;
_689998 = _689997 + converge_688171;
float _696123;
_696123 = _682661;
float _696309;
_696309 = _683071;
float _697742;
_697742 = 4.000000e+00f * _697741;
float _696829;
_696829 = _684213;
float _696297;
_696297 = _683045;
float _695877;
_695877 = _682117;
float _695954;
_695954 = _682290;
float _697387;
_697387 = _685435;
float _697189;
_697189 = _685003;
float _698144;
_698144 = _687096;
float _697428;
_697428 = _685526;
float _698432;
_698432 = _687730;
float _697623;
_697623 = _685957;
float _696068;
_696068 = _682540;
float _696933;
_696933 = _684443;
float _696795;
_696795 = _684133;
int _690877;
_690877 = converge_688258 * gwidth_681983;
float _697782;
_697782 = _686306;
float _695903;
_695903 = _682184;
float _696894;
_696894 = _684352;
float _698059;
_698059 = 4.000000e+00f * _698058;
float _697241;
_697241 = _685111;
float _697323;
_697323 = _685298;
float _697497;
_697497 = _685677;
float _697344;
_697344 = _685340;
float _698176;
_698176 = _687171;
float _696029;
_696029 = _682456;
float _698516;
_698516 = _687912;
float _696943;
_696943 = _684465;
float _696921;
_696921 = _684413;
float _696061;
_696061 = _682527;
float _697178;
_697178 = _684978;
float _696401;
_696401 = _683277;
float _698346;
_698346 = _687544;
float _696193;
_696193 = _682818;
int _693344;
_693344 = converge_688510 * gwidth_681983;
float _696495;
_696495 = _683482;
float _698221;
_698221 = _687267;
float _697031;
_697031 = _684660;
float _696480;
_696480 = _683446;
float _698413;
_698413 = 6.000000e+00f * _698412;
float _695981;
_695981 = _682351;
float _698029;
_698029 = _686845;
int _693485;
_693485 = _693344 + converge_688525;
float _697318;
_697318 = _685284;
int _693380;
_693380 = _693344 + converge_688516;
float _698233;
_698233 = _687292;
float _698493;
_698493 = 4.000000e+00f * _698492;
float _697908;
_697908 = _686578;
float _697605;
_697605 = _685913;
float _698127;
_698127 = _687061;
float _696947;
_696947 = _684473;
float _697164;
_697164 = _684948;
float _697735;
_697735 = _686204;
float _697079;
_697079 = 4.000000e+00f * _697078;
float _695892;
_695892 = 4.000000e+00f * _695891;
int _694576;
_694576 = converge_688636 * gwidth_681983;
float _696785;
_696785 = _684111;
float _698375;
_698375 = _687605;
float _697775;
_697775 = _686289;
float _696144;
_696144 = _682708;
int _694400;
_694400 = converge_688618 * gwidth_681983;
float _698418;
_698418 = _687700;
float _697916;
_697916 = _686597;
float _697040;
_697040 = _684676;
float _697304;
_697304 = _685254;
float _697024;
_697024 = 4.000000e+00f * _697023;
float _696173;
_696173 = _682769;
float _696055;
_696055 = _682516;
float _696312;
_696312 = _683076;
float _696133;
_696133 = _682683;
float _698510;
_698510 = _687902;
float _696743;
_696743 = _684026;
float _696716;
_696716 = _683960;
float _696017;
_696017 = _682431;
float _696124;
_696124 = _682667;
float _697150;
_697150 = _684918;
float _696948;
_696948 = _684479;
float _696224;
_696224 = _682884;
float _695830;
_695830 = _682013;
float _697644;
_697644 = _686004;
float _696651;
_696651 = _683821;
float _697854;
_697854 = _686462;
float _697505;
_697505 = _685697;
float _697433;
_697433 = _685540;
float _695951;
_695951 = _682285;
float _698473;
_698473 = _687821;
float _696778;
_696778 = 4.000000e+00f * _696777;
float _697706;
_697706 = _686138;
float _696310;
_696310 = 4.000000e+00f * _696309;
float _697779;
_697779 = _686301;
float _696760;
_696760 = _684062;
float _697173;
_697173 = 6.000000e+00f * _697172;
float _696474;
_696474 = 4.000000e+00f * _696473;
float _696975;
_696975 = _684533;
float _697123;
_697123 = _684857;
float _698423;
_698423 = _687714;
float _697661;
_697661 = _686039;
float _696846;
_696846 = _684248;
float _696013;
_696013 = _682419;
float _697666;
_697666 = _686053;
float _696867;
_696867 = _684298;
float _695910;
_695910 = 4.000000e+00f * _695909;
float _698083;
_698083 = _686965;
float _697120;
_697120 = _684852;
float _696110;
_696110 = _682637;
float _696342;
_696342 = _683144;
float _697724;
_697724 = _686180;
float _698279;
_698279 = _687393;
int _689999;
_689999 = 14 * _689998;
float _696496;
_696496 = 4.000000e+00f * _696495;
float _697903;
_697903 = 4.000000e+00f * _697902;
float _698447;
_698447 = _687761;
float _698020;
_698020 = _686824;
float _697749;
_697749 = _686229;
float _698429;
_698429 = _687725;
float _697064;
_697064 = 6.000000e+00f * _697063;
float _696329;
_696329 = _683120;
float _696798;
_696798 = _684147;
int _693169;
_693169 = _693168 + converge_688495;
float _698300;
_698300 = _687443;
float _696802;
_696802 = 6.000000e+00f * _696801;
float _697456;
_697456 = _685586;
float _697925;
_697925 = _686613;
float _697566;
_697566 = _685828;
float _698179;
_698179 = _687177;
float _697450;
_697450 = _685576;
float _696415;
_696415 = _683307;
float _695900;
_695900 = _682170;
float _696625;
_696625 = _683765;
float _698441;
_698441 = _687751;
float _698534;
_698534 = 4.000000e+00f * _698533;
float _696426;
_696426 = _683331;
int _692887;
_692887 = _692816 + converge_688465;
float _697437;
_697437 = 6.000000e+00f * _697436;
float _696839;
_696839 = _684231;
float _697819;
_697819 = _686386;
float _696628;
_696628 = _683770;
float _697494;
_697494 = _685672;
float _696466;
_696466 = _683416;
float _697544;
_697544 = _685776;
float zf_695810;
zf_695810 = zv_681988 - _695809;
float _698459;
_698459 = _687791;
float _697337;
_697337 = _685323;
float _697996;
_697996 = _686772;
float _696216;
_696216 = _682864;
float _696575;
_696575 = _683649;
float _698150;
_698150 = 4.000000e+00f * _698149;
int _691054;
_691054 = _691053 + converge_688279;
float _696287;
_696287 = _683023;
float _696694;
_696694 = _683916;
float _695878;
_695878 = _682123;
float _696467;
_696467 = _683422;
float _696912;
_696912 = _684394;
int _693170;
_693170 = 14 * _693169;
float _697032;
_697032 = 4.000000e+00f * _697031;
float _696720;
_696720 = _683972;
float _697675;
_697675 = _686069;
float _697893;
_697893 = _686543;
float _695912;
_695912 = _682200;
int _690455;
_690455 = _690349 + converge_688216;
float _697190;
_697190 = 4.000000e+00f * _697189;
float _697944;
_697944 = _686657;
int _691124;
_691124 = _691053 + converge_688285;
float _696277;
_696277 = _683005;
float _697006;
_697006 = _684606;
float _698481;
_698481 = _687841;
float _696283;
_696283 = _683015;
int _694647;
_694647 = _694576 + converge_688645;
float _696501;
_696501 = _683493;
float _697896;
_697896 = _686548;
float _697280;
_697280 = _685202;
float _695931;
_695931 = _682244;
int _689751;
_689751 = _689645 + converge_688144;
float _697007;
_697007 = 6.000000e+00f * _697006;
float _697281;
_697281 = _685208;
float _697734;
_697734 = _686198;
float _696494;
_696494 = _683476;
int _691933;
_691933 = converge_688366 * gwidth_681983;
float _697738;
_697738 = _686210;
int _693239;
_693239 = _693168 + converge_688501;
float _698025;
_698025 = _686833;
float _697727;
_697727 = _686185;
float _696957;
_696957 = _684495;
float _697516;
_697516 = _685721;
float _697246;
_697246 = 6.000000e+00f * _697245;
float _697332;
_697332 = _685314;
float _698360;
_698360 = _687574;
float _697410;
_697410 = _685486;
int _694506;
_694506 = _694400 + converge_688630;
float _697658;
_697658 = _686034;
float _697128;
_697128 = _684866;
float _697401;
_697401 = _685465;
float _698107;
_698107 = _687020;
float _697045;
_697045 = _684690;
float _698540;
_698540 = 4.000000e+00f * _698539;
float _698035;
_698035 = _686855;
float _696243;
_696243 = _682925;
float _697681;
_697681 = _686084;
float _696991;
_696991 = _684570;
float _697231;
_697231 = _685093;
float _698199;
_698199 = _687217;
float _696324;
_696324 = _683106;
float _697103;
_697103 = _684817;
int _690525;
_690525 = converge_688222 * gwidth_681983;
float _697467;
_697467 = _685611;
int _694541;
_694541 = _694400 + converge_688633;
float _696675;
_696675 = 4.000000e+00f * _696674;
float _696178;
_696178 = _682782;
float _696199;
_696199 = _682829;
float _695833;
_695833 = _682019;
float _696711;
_696711 = _683951;
float _697223;
_697223 = _685073;
float _697835;
_697835 = 6.000000e+00f * _697834;
float _696356;
_696356 = _683174;
int _691405;
_691405 = converge_688312 * gwidth_681983;
float _698276;
_698276 = _687388;
float _698182;
_698182 = _687182;
float _696220;
_696220 = _682872;
float _697950;
_697950 = _686668;
float _697933;
_697933 = _686633;
float _696137;
_696137 = _682691;
float _696968;
_696968 = _684520;
float _696816;
_696816 = 6.000000e+00f * _696815;
float _695906;
_695906 = _682190;
float _695926;
_695926 = _682230;
float _698006;
_698006 = _686794;
float _698491;
_698491 = _687859;
int _695492;
_695492 = _695456 + converge_688732;
float _698376;
_698376 = 4.000000e+00f * _698375;
float _697202;
_697202 = _685026;
float _697621;
_697621 = _685949;
float _697227;
_697227 = _685081;
float _698561;
_698561 = _688016;
int _694436;
_694436 = _694400 + converge_688624;
float _696559;
_696559 = 4.000000e+00f * _696558;
float _696512;
_696512 = _683513;
float _696206;
_696206 = _682842;
float _696962;
_696962 = _684509;
float _696969;
_696969 = 4.000000e+00f * _696968;
float _697862;
_697862 = _686482;
float _697054;
_697054 = _684706;
float _696518;
_696518 = _683524;
float _697627;
_697627 = _685969;
float _697176;
_697176 = 4.000000e+00f * _697175;
float _697411;
_697411 = 6.000000e+00f * _697410;
int _694648;
_694648 = 14 * _694647;
float _697370;
_697370 = _685400;
float _697761;
_697761 = _686259;
float _695916;
_695916 = _682208;
float _696821;
_696821 = _684193;
float _697588;
_697588 = _685878;
float _697624;
_697624 = _685963;
float _696444;
_696444 = _683368;
int _692957;
_692957 = _692816 + converge_688471;
int _695812;
_695812 = gid_y_681209 % 8;
float _696774;
_696774 = _684092;
float _698570;
_698570 = _688032;
float _695934;
_695934 = _682250;
float _696452;
_696452 = _683386;
float _698044;
_698044 = _686880;
float _698218;
_698218 = _687261;
int _690701;
_690701 = converge_688240 * gwidth_681983;
float _696673;
_696673 = _683869;
float _696303;
_696303 = _683060;
float _698301;
_698301 = 4.000000e+00f * _698300;
float _697156;
_697156 = 4.000000e+00f * _697155;
float _695960;
_695960 = _682305;
float _697416;
_697416 = _685496;
float _697685;
_697685 = 6.000000e+00f * _697684;
float _696054;
_696054 = _682510;
float _698484;
_698484 = _687846;
float _698248;
_698248 = _687328;
float _696992;
_696992 = 4.000000e+00f * _696991;
float _696583;
_696583 = 6.000000e+00f * _696582;
float _696538;
_696538 = _683573;
float _696804;
_696804 = _684158;
float _695949;
_695949 = 6.000000e+00f * _695948;
float _698453;
_698453 = _687781;
float _697030;
_697030 = _684654;
float _697790;
_697790 = _686325;
float _697135;
_697135 = _684883;
float _696502;
_696502 = 4.000000e+00f * _696501;
float _698381;
_698381 = _687624;
float _698180;
_698180 = 6.000000e+00f * _698179;
float _696330;
_696330 = 4.000000e+00f * _696329;
float _696247;
_696247 = 4.000000e+00f * _696246;
int _693204;
_693204 = _693168 + converge_688498;
float _697100;
_697100 = _684811;
float _698227;
_698227 = _687277;
float _696866;
_696866 = _684292;
float _697485;
_697485 = _685647;
float _697138;
_697138 = _684888;
float _696260;
_696260 = _682969;
float _698354;
_698354 = _687563;
float _697667;
_697667 = 4.000000e+00f * _697666;
float _698277;
_698277 = 6.000000e+00f * _698276;
float _698249;
_698249 = 6.000000e+00f * _698248;
float _696427;
_696427 = 4.000000e+00f * _696426;
float _698251;
_698251 = _687333;
float _698268;
_698268 = _687368;
float _697554;
_697554 = _685798;
float _698326;
_698326 = _687503;
float _698196;
_698196 = _687212;
float _696691;
_696691 = _683911;
float _698408;
_698408 = _687678;
float _697990;
_697990 = 4.000000e+00f * _697989;
float _696459;
_696459 = _683403;
float _696890;
_696890 = _684344;
float _697071;
_697071 = _684745;
float _698312;
_698312 = _687473;
float _696746;
_696746 = _684032;
float _698210;
_698210 = _687242;
float _697282;
_697282 = 4.000000e+00f * _697281;
float _697316;
_697316 = 4.000000e+00f * _697315;
float _697696;
_697696 = _686120;
float _697350;
_697350 = _685359;
int _694717;
_694717 = _694576 + converge_688651;
int _690983;
_690983 = _690877 + converge_688270;
float _697699;
_697699 = _686125;
float _696841;
_696841 = 4.000000e+00f * _696840;
float _696980;
_696980 = 6.000000e+00f * _696979;
float _695961;
_695961 = 4.000000e+00f * _695960;
float _697398;
_697398 = _685460;
int _694471;
_694471 = _694400 + converge_688627;
float _698120;
_698120 = _687044;
float _696207;
_696207 = _682848;
int _693486;
_693486 = 14 * _693485;
float _697298;
_697298 = _685244;
float _697720;
_697720 = _686168;
float _696070;
_696070 = 4.000000e+00f * _696069;
float _698219;
_698219 = 4.000000e+00f * _698218;
float _697665;
_697665 = _686047;
float _696116;
_696116 = _682648;
float _697002;
_697002 = _684594;
float _696729;
_696729 = _683996;
float _696375;
_696375 = _683217;
float _697652;
_697652 = _686023;
float _696742;
_696742 = _684020;
float _696064;
_696064 = _682532;
float _697154;
_697154 = _684926;
float _696306;
_696306 = _683066;
float _697140;
_697140 = _684896;
int _694577;
_694577 = _694576 + converge_688639;
float _695836;
_695836 = _682033;
float _698550;
_698550 = _687992;
float _695924;
_695924 = 4.000000e+00f * _695923;
float _697373;
_697373 = _685405;
float _697602;
_697602 = _685908;
float _696904;
_696904 = _684374;
float _696182;
_696182 = _682794;
float _698258;
_698258 = _687346;
float _697520;
_697520 = 6.000000e+00f * _697519;
float _697157;
_697157 = _697154 + _697156;
float _696982;
_696982 = _684550;
float _696728;
_696728 = _683990;
float _696331;
_696331 = _696328 + _696330;
float _697630;
_697630 = _685974;
float _696793;
_696793 = 4.000000e+00f * _696792;
int _694224;
_694224 = converge_688600 * gwidth_681983;
float _696421;
_696421 = _683317;
float _695975;
_695975 = _682341;
float _697832;
_697832 = 4.000000e+00f * _697831;
float _697012;
_697012 = _684616;
float _698404;
_698404 = _687670;
float _698190;
_698190 = _687201;
float _698325;
_698325 = _687497;
float _696261;
_696261 = 4.000000e+00f * _696260;
int _690807;
_690807 = _690701 + converge_688252;
int _689082;
_689082 = _688941 + converge_688075;
float _697638;
_697638 = _685993;
float _695993;
_695993 = 4.000000e+00f * _695992;
float _697016;
_697016 = _684624;
float _698330;
_698330 = 6.000000e+00f * _698329;
float _697329;
_697329 = _685309;
float _698485;
_698485 = 4.000000e+00f * _698484;
float _696397;
_696397 = _683265;
float _698456;
_698456 = _687786;
float _697687;
_697687 = _686095;
float _696390;
_696390 = _683252;
float _697930;
_697930 = _686627;
float _697283;
_697283 = _697280 + _697282;
float _697242;
_697242 = _685117;
float _696432;
_696432 = _683342;
float _697345;
_697345 = 4.000000e+00f * _697344;
float _696738;
_696738 = _684012;
float _696211;
_696211 = 6.000000e+00f * _696210;
float _698369;
_698369 = _687594;
float _697901;
_697901 = _686561;
float _698053;
_698053 = 4.000000e+00f * _698052;
int _690702;
_690702 = _690701 + converge_688243;
float _696954;
_696954 = _684490;
float _698167;
_698167 = _687147;
float _698556;
_698556 = _688002;
float _696513;
_696513 = 4.000000e+00f * _696512;
float _696736;
_696736 = 4.000000e+00f * _696735;
float _697525;
_697525 = _685737;
float _697557;
_697557 = _685812;
float _698335;
_698335 = _687519;
float _697385;
_697385 = 4.000000e+00f * _697384;
float _697338;
_697338 = _685329;
float _696105;
_696105 = 4.000000e+00f * _696104;
float _696757;
_696757 = _684056;
float _696407;
_696407 = _683287;
float _696238;
_696238 = 6.000000e+00f * _696237;
float _696278;
_696278 = 6.000000e+00f * _696277;
float _697351;
_697351 = 4.000000e+00f * _697350;
float _696192;
_696192 = _682812;
float _696626;
_696626 = 4.000000e+00f * _696625;
float _696870;
_696870 = _684304;
int _688761;
_688761 = converge_688042 * gwidth_681983;
float _696141;
_696141 = _682703;
float _698244;
_698244 = _687316;
float _696749;
_696749 = _684037;
float _696021;
_696021 = 4.000000e+00f * _696020;
float _697117;
_697117 = _684847;
float _697997;
_697997 = _686778;
float _697934;
_697934 = 6.000000e+00f * _697933;
float _697208;
_697208 = _685037;
float _696561;
_696561 = _683619;
float _697312;
_697312 = _685274;
int _692992;
_692992 = converge_688474 * gwidth_681983;
float _695884;
_695884 = _682134;
float _696881;
_696881 = _684328;
int _694472;
_694472 = 14 * _694471;
float _696669;
_696669 = _683861;
float _696188;
_696188 = _682804;
float _696654;
_696654 = _683826;
int _693345;
_693345 = _693344 + converge_688513;
float _698357;
_698357 = _687569;
float _697909;
_697909 = 4.000000e+00f * _697908;
float _697837;
_697837 = _686427;
float _697255;
_697255 = _685141;
int _694048;
_694048 = converge_688582 * gwidth_681983;
float _698128;
_698128 = 4.000000e+00f * _698127;
float _697697;
_697697 = 6.000000e+00f * _697696;
float _697003;
_697003 = _684600;
float _696352;
_696352 = _683166;
float _698511;
_698511 = 6.000000e+00f * _698510;
float _696366;
_696366 = _683196;
float _697894;
_697894 = 6.000000e+00f * _697893;
float _696797;
_696797 = _684141;
float _696213;
_696213 = _682859;
float _697570;
_697570 = _685836;
float _697972;
_697972 = _686724;
float _697214;
_697214 = _685057;
float _696186;
_696186 = 4.000000e+00f * _696185;
float _696291;
_696291 = _683035;
float _695976;
_695976 = 6.000000e+00f * _695975;
float _698525;
_698525 = _687937;
float _697407;
_697407 = _685480;
float _697182;
_697182 = _684986;
float _696726;
_696726 = _683982;
float _697465;
_697465 = 6.000000e+00f * _697464;
float _697201;
_697201 = _685019;
float _696252;
_696252 = _682950;
float _696705;
_696705 = _683941;
int _689329;
_689329 = _689293 + converge_688102;
float _698542;
_698542 = _687972;
float _697728;
_697728 = 4.000000e+00f * _697727;
float _697046;
_697046 = 4.000000e+00f * _697045;
float _697262;
_697262 = _685158;
float _696288;
_696288 = _683029;
float _696511;
_696511 = _683507;
int _690173;
_690173 = converge_688186 * gwidth_681983;
float _698378;
_698378 = _687610;
float _697736;
_697736 = 4.000000e+00f * _697735;
float _697872;
_697872 = _686500;
int _694189;
_694189 = _694048 + converge_688597;
float _696666;
_696666 = _683856;
float _697089;
_697089 = _684787;
float _696910;
_696910 = 4.000000e+00f * _696909;
float _696391;
_696391 = 4.000000e+00f * _696390;
float _698280;
_698280 = 4.000000e+00f * _698279;
float _696639;
_696639 = _683795;
float _697092;
_697092 = _684792;
int _691159;
_691159 = _691053 + converge_688288;
float _696456;
_696456 = _683398;
float _697186;
_697186 = _684998;
float _696255;
_696255 = _682955;
int _691018;
_691018 = _690877 + converge_688273;
float _697692;
_697692 = _686108;
float _698318;
_698318 = _687484;
float _698017;
_698017 = _686819;
int _690244;
_690244 = _690173 + converge_688195;
float _698262;
_698262 = _687358;
float _697813;
_697813 = _686371;
float _697647;
_697647 = _686009;
int _694578;
_694578 = 14 * _694577;
float _696633;
_696633 = _683784;
float _697897;
_697897 = 4.000000e+00f * _697896;
float _698004;
_698004 = 4.000000e+00f * _698003;
float _698026;
_698026 = _686839;
float _698153;
_698153 = 6.000000e+00f * _698152;
float _698101;
_698101 = _687001;
float _697830;
_697830 = _686410;
float _696208;
_696208 = 4.000000e+00f * _696207;
float _696556;
_696556 = 6.000000e+00f * _696555;
float _695849;
_695849 = _682057;
int _691757;
_691757 = converge_688348 * gwidth_681983;
float _697144;
_697144 = _684908;
float _698501;
_698501 = _687881;
float _697000;
_697000 = _684586;
float _697721;
_697721 = _686174;
float _696109;
_696109 = _682631;
float _698293;
_698293 = _687423;
float _696119;
_696119 = _682653;
float _698236;
_698236 = _687298;
float _695823;
_695823 = _682002;
float _698130;
_698130 = _687066;
float _696844;
_696844 = 6.000000e+00f * _696843;
int _694612;
_694612 = _694576 + converge_688642;
float _698165;
_698165 = 4.000000e+00f * _698164;
float _697891;
_697891 = 4.000000e+00f * _697890;
float _698477;
_698477 = _687829;
float _698245;
_698245 = _687322;
float _696761;
_696761 = 6.000000e+00f * _696760;
float _697232;
_697232 = 6.000000e+00f * _697231;
float _698102;
_698102 = 4.000000e+00f * _698101;
float _696931;
_696931 = _684435;
float _697931;
_697931 = 4.000000e+00f * _697930;
float _696597;
_696597 = _683705;
float _698430;
_698430 = 4.000000e+00f * _698429;
float _698158;
_698158 = _687126;
float _696076;
_696076 = 4.000000e+00f * _696075;
float _698079;
_698079 = _686953;
float _695986;
_695986 = _682365;
float _696780;
_696780 = _684102;
float _697556;
_697556 = _685806;
float _698390;
_698390 = _687640;
float _698463;
_698463 = _687799;
float _696864;
_696864 = _684284;
float _697453;
_697453 = _685581;
float _697381;
_697381 = _685425;
float _696078;
_696078 = _682562;
float _698398;
_698398 = _687660;
float _696825;
_696825 = _684201;
float _698388;
_698388 = 4.000000e+00f * _698387;
float _696901;
_696901 = _684369;
float _697879;
_697879 = _686517;
float _698011;
_698011 = _686808;
float _697422;
_697422 = _685516;
float _697966;
_697966 = _686704;
float _697391;
_697391 = _685443;
float _698302;
_698302 = _698299 + _698301;
float _697818;
_697818 = _686380;
float _697106;
_697106 = _684822;
float _698294;
_698294 = 4.000000e+00f * _698293;
float _696294;
_696294 = _683040;
float _696813;
_696813 = 4.000000e+00f * _696812;
float _697278;
_697278 = _685194;
float _696647;
_696647 = _683809;
float _697414;
_697414 = 4.000000e+00f * _697413;
float _696092;
_696092 = _682592;
float _696245;
_696245 = _682933;
float _695850;
_695850 = _682063;
float _697577;
_697577 = _685853;
float _698303;
_698303 = _687449;
int _693521;
_693521 = _693520 + converge_688531;
float _696971;
_696971 = _684525;
float _695813;
_695813 = (float)_695812;
int _691476;
_691476 = _691405 + converge_688321;
float _697769;
_697769 = 4.000000e+00f * _697768;
float _697141;
_697141 = _684902;
float _696498;
_696498 = _683488;
float _698363;
_698363 = _687579;
float _696858;
_696858 = _684274;
float _696887;
_696887 = _684339;
float _697511;
_697511 = _685707;
float _697353;
_697353 = _685365;
float _696515;
_696515 = _683519;
float _697129;
_697129 = _684872;
float _696304;
_696304 = 4.000000e+00f * _696303;
float _697365;
_697365 = 4.000000e+00f * _697364;
float _697707;
_697707 = _686144;
float _697653;
_697653 = 4.000000e+00f * _697652;
float _698121;
_698121 = _687050;
float _697515;
_697515 = _685715;
float _695969;
_695969 = _682321;
float _696411;
_696411 = _683295;
float _697759;
_697759 = _686251;
float _696588;
_696588 = _683680;
float _696249;
_696249 = _682945;
float _697936;
_697936 = _686638;
float _698495;
_698495 = _687871;
float _697506;
_697506 = 6.000000e+00f * _697505;
float _697866;
_697866 = 4.000000e+00f * _697865;
float _696683;
_696683 = _683891;
float _696041;
_696041 = _682486;
float _696811;
_696811 = _684171;
float _696605;
_696605 = _683724;
float _695835;
_695835 = _682027;
float _696372;
_696372 = _683211;
float _697929;
_697929 = _686621;
float _697462;
_697462 = 4.000000e+00f * _697461;
float _697763;
_697763 = 4.000000e+00f * _697762;
float _696598;
_696598 = 4.000000e+00f * _696597;
float _695873;
_695873 = _682109;
float _698217;
_698217 = _687255;
float _696383;
_696383 = _683235;
float _697889;
_697889 = _686531;
float _696233;
_696233 = _682903;
float _697825;
_697825 = _686397;
float _698438;
_698438 = _687745;
float _697020;
_697020 = _684636;
float _697090;
_697090 = 6.000000e+00f * _697089;
int _688906;
_688906 = _688761 + converge_688057;
float _696072;
_696072 = _682552;
float _697145;
_697145 = 6.000000e+00f * _697144;
int _694752;
_694752 = converge_688654 * gwidth_681983;
int _694084;
_694084 = _694048 + converge_688588;
float _696830;
_696830 = 6.000000e+00f * _696829;
float _697548;
_697548 = _685788;
float _698242;
_698242 = _687308;
float _696899;
_696899 = 6.000000e+00f * _696898;
float _696035;
_696035 = _682467;
float _695937;
_695937 = _682255;
float _696702;
_696702 = _683935;
float _696102;
_696102 = 6.000000e+00f * _696101;
float _698163;
_698163 = _687135;
float _697275;
_697275 = _685189;
int _692004;
_692004 = _691933 + converge_688375;
float _696730;
_696730 = 4.000000e+00f * _696729;
float _697558;
_697558 = 4.000000e+00f * _697557;
int _693063;
_693063 = _692992 + converge_688483;
float _697367;
_697367 = _685395;
float _696614;
_696614 = _683740;
float _696585;
_696585 = _683675;
int _695280;
_695280 = converge_688708 * gwidth_681983;
float _696537;
_696537 = _683567;
float _698373;
_698373 = 6.000000e+00f * _698372;
float _696225;
_696225 = 6.000000e+00f * _696224;
float _697287;
_697287 = _685219;
int _692852;
_692852 = _692816 + converge_688462;
float zv_688764;
zv_688764 = 1.000000e+01f * converge_688039;
float _698507;
_698507 = _687896;
float _697218;
_697218 = 6.000000e+00f * _697217;
int _695457;
_695457 = _695456 + converge_688729;
float _695963;
_695963 = _682311;
int _691581;
_691581 = converge_688330 * gwidth_681983;
int _693626;
_693626 = _693520 + converge_688540;
float _698246;
_698246 = 4.000000e+00f * _698245;
float _696445;
_696445 = 6.000000e+00f * _696444;
float _696923;
_696923 = 4.000000e+00f * _696922;
float _697442;
_697442 = _685556;
float _696541;
_696541 = _683579;
float _695853;
_695853 = _682069;
float _697272;
_697272 = _685184;
float _696604;
_696604 = _683718;
int _691722;
_691722 = _691581 + converge_688345;
float _698260;
_698260 = 4.000000e+00f * _698259;
int _691934;
_691934 = _691933 + converge_688369;
float _696343;
_696343 = _683150;
float _697756;
_697756 = _686246;
float _696228;
_696228 = 4.000000e+00f * _696227;
float _697859;
_697859 = _686476;
float _697356;
_697356 = _685370;
float _697158;
_697158 = _684938;
float _696230;
_696230 = _682894;
float _695856;
_695856 = _682074;
float _698204;
_698204 = _687231;
float _697104;
_697104 = 6.000000e+00f * _697103;
float _697228;
_697228 = _685087;
float _698191;
_698191 = 4.000000e+00f * _698190;
float _697301;
_697301 = _685249;
int _695632;
_695632 = converge_688744 * gwidth_681983;
float _695842;
_695842 = _682044;
float _696688;
_696688 = _683905;
int _691089;
_691089 = _691053 + converge_688282;
float _696527;
_696527 = _683549;
float _697580;
_697580 = _685858;
float _697066;
_697066 = _684732;
float _696882;
_696882 = 4.000000e+00f * _696881;
float _695932;
_695932 = 4.000000e+00f * _695931;
float _697844;
_697844 = _686440;
float _697641;
_697641 = _685999;
float _697121;
_697121 = 4.000000e+00f * _697120;
float _696660;
_696660 = _683845;
float _698261;
_698261 = _698258 + _698260;
float _697899;
_697899 = _686553;
float _696376;
_696376 = 6.000000e+00f * _696375;
float _696807;
_696807 = _684163;
float _696321;
_696321 = _683101;
float _696425;
_696425 = _683325;
float _696058;
_696058 = _682522;
float _698155;
_698155 = _687121;
float _697851;
_697851 = _686457;
float _695864;
_695864 = _682093;
float _696412;
_696412 = _683301;
int _690385;
_690385 = _690349 + converge_688210;
float _697502;
_697502 = _685691;
float _695940;
_695940 = _682260;
float _696657;
_696657 = _683831;
float _698286;
_698286 = _687406;
float _696470;
_696470 = _683428;
float _698069;
_698069 = _686935;
float _695818;
_695818 = (float)_695817;
int _693872;
_693872 = converge_688564 * gwidth_681983;
int _689821;
_689821 = converge_688150 * gwidth_681983;
float _697371;
_697371 = 4.000000e+00f * _697370;
float _696833;
_696833 = 4.000000e+00f * _696832;
int _694295;
_694295 = _694224 + converge_688609;
float _698106;
_698106 = _687014;
float _697072;
_697072 = _684751;
float _697757;
_697757 = 4.000000e+00f * _697756;
float _697034;
_697034 = _684666;
int _690138;
_690138 = _689997 + converge_688183;
float _698124;
_698124 = _687056;
float _698224;
_698224 = _687272;
float _696098;
_696098 = _682607;
float _697753;
_697753 = _686241;
float _698499;
_698499 = 4.000000e+00f * _698498;
float _697953;
_697953 = _686673;
float _696756;
_696756 = _684050;
float _696747;
_696747 = 6.000000e+00f * _696746;
int _690174;
_690174 = _690173 + converge_688189;
float _696047;
_696047 = _682497;
float _696855;
_696855 = _684268;
float _696089;
_696089 = _682587;
float _696814;
_696814 = _696811 + _696813;
float _698183;
_698183 = 4.000000e+00f * _698182;
float _695897;
_695897 = _682165;
float _696003;
_696003 = _682401;
float _696883;
_696883 = _696880 + _696882;
float _696429;
_696429 = _683337;
float _698313;
_698313 = 4.000000e+00f * _698312;
float _696315;
_696315 = _683090;
float _696818;
_696818 = _684188;
float _697396;
_697396 = 6.000000e+00f * _697395;
float _698189;
_698189 = _687195;
float _696524;
_696524 = _683543;
float _697209;
_697209 = 4.000000e+00f * _697208;
int _691793;
_691793 = _691757 + converge_688354;
float _697354;
_697354 = 6.000000e+00f * _697353;
float _695894;
_695894 = _682160;
float _696965;
_696965 = _684515;
float _697968;
_697968 = _686712;
float _696723;
_696723 = _683977;
float _697475;
_697475 = _685625;
float _697598;
_697598 = _685896;
float _696590;
_696590 = _683688;
float _696453;
_696453 = _683392;
float _697480;
_697480 = 6.000000e+00f * _697479;
float _696402;
_696402 = 6.000000e+00f * _696401;
float _696861;
_696861 = _684279;
int _689681;
_689681 = _689645 + converge_688138;
int _694823;
_694823 = _694752 + converge_688663;
int _692640;
_692640 = converge_688438 * gwidth_681983;
float _698562;
_698562 = 4.000000e+00f * _698561;
float _696949;
_696949 = 4.000000e+00f * _696948;
float _696934;
_696934 = _684449;
int _693098;
_693098 = _692992 + converge_688486;
float _696664;
_696664 = 6.000000e+00f * _696663;
float _697406;
_697406 = _685474;
float _698138;
_698138 = _687086;
int _695104;
_695104 = converge_688690 * gwidth_681983;
float _697789;
_697789 = _686319;
float _697392;
_697392 = _685449;
float _696462;
_696462 = _683408;
float _698038;
_698038 = _686869;
float _696721;
_696721 = 6.000000e+00f * _696720;
float _696030;
_696030 = 4.000000e+00f * _696029;
float _696481;
_696481 = _683452;
float _697600;
_697600 = 4.000000e+00f * _697599;
float _696913;
_696913 = 6.000000e+00f * _696912;
float _698273;
_698273 = _687382;
float _697308;
_697308 = _685262;
int _691229;
_691229 = converge_688294 * gwidth_681983;
float _696253;
_696253 = 4.000000e+00f * _696252;
float _695839;
_695839 = _682039;
float _698096;
_698096 = 4.000000e+00f * _698095;
float _698213;
_698213 = _687247;
float _698032;
_698032 = _686850;
float _697017;
_697017 = _684630;
float _697702;
_697702 = _686130;
float _698141;
_698141 = _687091;
int _692464;
_692464 = converge_688420 * gwidth_681983;
float _696862;
_696862 = 4.000000e+00f * _696861;
float _697873;
_697873 = _686506;
float _697324;
_697324 = 4.000000e+00f * _697323;
float _697326;
_697326 = _685304;
float _698272;
_698272 = _687376;
float _695967;
_695967 = 4.000000e+00f * _695966;
int _689646;
_689646 = _689645 + converge_688135;
int _693240;
_693240 = 14 * _693239;
float _697501;
_697501 = _685685;
int _695386;
_695386 = _695280 + converge_688720;
float _697339;
_697339 = 4.000000e+00f * _697338;
int _694401;
_694401 = _694400 + converge_688621;
float _696926;
_696926 = 6.000000e+00f * _696925;
float _697917;
_697917 = 4.000000e+00f * _697916;
float _698065;
_698065 = _686923;
float _695907;
_695907 = 6.000000e+00f * _695906;
float _698108;
_698108 = 4.000000e+00f * _698107;
int _692922;
_692922 = _692816 + converge_688468;
float _696718;
_696718 = 4.000000e+00f * _696717;
float _698380;
_698380 = _687618;
int _689294;
_689294 = _689293 + converge_688099;
float _698156;
_698156 = 4.000000e+00f * _698155;
float _696373;
_696373 = 4.000000e+00f * _696372;
float _696592;
_696592 = 4.000000e+00f * _696591;
float _697905;
_697905 = _686573;
float _698018;
_698018 = 4.000000e+00f * _698017;
float _697048;
_697048 = _684696;
int _689364;
_689364 = _689293 + converge_688105;
float _695811;
_695811 = 1.000000e+00f - zf_695810;
float _696766;
_696766 = _684072;
float _698014;
_698014 = _686814;
float _697693;
_697693 = _686114;
float _698416;
_698416 = 4.000000e+00f * _698415;
float _696086;
_696086 = _682582;
float _697776;
_697776 = _686295;
float _697529;
_697529 = _685745;
float _697563;
_697563 = _685823;
float _697611;
_697611 = _685927;
float _697205;
_697205 = _685032;
int _690948;
_690948 = _690877 + converge_688267;
float _697539;
_697539 = _685767;
int _691090;
_691090 = 14 * _691089;
float _696611;
_696611 = _683735;
float _698399;
_698399 = 6.000000e+00f * _698398;
int _694858;
_694858 = _694752 + converge_688666;
float _697237;
_697237 = _685103;
float _698551;
_698551 = 6.000000e+00f * _698550;
float _697349;
_697349 = _685353;
int _694718;
_694718 = 14 * _694717;
float _696393;
_696393 = _683257;
float _697341;
_697341 = _685335;
float _697213;
_697213 = _685051;
float _698384;
_698384 = _687630;
float _697939;
_697939 = _686643;
int _690279;
_690279 = _690173 + converge_688198;
float _696006;
_696006 = _682406;
float _698086;
_698086 = _686970;
float _697408;
_697408 = 4.000000e+00f * _697407;
float _697161;
_697161 = _684943;
float _697672;
_697672 = _686064;
int _695597;
_695597 = _695456 + converge_688741;
float _696569;
_696569 = _683639;
int _695633;
_695633 = _695632 + converge_688747;
float _697085;
_697085 = _684775;
float _696764;
_696764 = 4.000000e+00f * _696763;
float _698110;
_698110 = _687026;
float _696155;
_696155 = _682733;
float _697919;
_697919 = _686603;
int _691511;
_691511 = _691405 + converge_688324;
float _697352;
_697352 = _697349 + _697351;
float _695843;
_695843 = 4.000000e+00f * _695842;
float _698564;
_698564 = _688022;
int _688942;
_688942 = _688941 + converge_688063;
float _696387;
_696387 = _683247;
float _698113;
_698113 = _687031;
float _697882;
_697882 = _686522;
float _696289;
_696289 = 4.000000e+00f * _696288;
int _695493;
_695493 = 14 * _695492;
float _697690;
_697690 = _686100;
float _698254;
_698254 = _687338;
float _696915;
_696915 = _684399;
int _692039;
_692039 = _691933 + converge_688378;
float _698290;
_698290 = _687418;
float _696553;
_696553 = 4.000000e+00f * _696552;
float _698347;
_698347 = 4.000000e+00f * _698346;
float _696750;
_696750 = 4.000000e+00f * _696749;
float _695990;
_695990 = 6.000000e+00f * _695989;
float _697765;
_697765 = _686271;
float _695859;
_695859 = _682079;
float _696773;
_696773 = _696770 + _696772;
float _697619;
_697619 = 4.000000e+00f * _697618;
int _695421;
_695421 = _695280 + converge_688723;
float _696530;
_696530 = _683554;
float _696744;
_696744 = 4.000000e+00f * _696743;
float _696441;
_696441 = _683362;
float _696594;
_696594 = _683700;
float _696305;
_696305 = _696302 + _696304;
int _690456;
_690456 = 14 * _690455;
float _697822;
_697822 = _686392;
float _697206;
_697206 = 6.000000e+00f * _697205;
int _694788;
_694788 = _694752 + converge_688660;
int _690314;
_690314 = _690173 + converge_688201;
float _697631;
_697631 = 4.000000e+00f * _697630;
float _696937;
_696937 = _684455;
int _694296;
_694296 = 14 * _694295;
float _696221;
_696221 = _682878;
float _698467;
_698467 = _687811;
int _691265;
_691265 = _691229 + converge_688300;
float _696336;
_696336 = 4.000000e+00f * _696335;
float _698139;
_698139 = 6.000000e+00f * _698138;
float _697268;
_697268 = _685172;
float _697771;
_697771 = _686281;
float _695964;
_695964 = 6.000000e+00f * _695963;
float _698027;
_698027 = 4.000000e+00f * _698026;
float _696167;
_696167 = _682758;
float _696000;
_696000 = _682395;
float _695887;
_695887 = _682139;
float _696111;
_696111 = 4.000000e+00f * _696110;
float _696497;
_696497 = _696494 + _696496;
float _697793;
_697793 = _686331;
float _698037;
_698037 = _686863;
float _698401;
_698401 = _687665;
float _695904;
_695904 = 4.000000e+00f * _695903;
float _696014;
_696014 = _682425;
float _697147;
_697147 = _684913;
float _698471;
_698471 = 4.000000e+00f * _698470;
float _697044;
_697044 = _684684;
int _689434;
_689434 = _689293 + converge_688111;
float _697447;
_697447 = _685570;
float _698353;
_698353 = _687557;
float _696709;
_696709 = 4.000000e+00f * _696708;
int _691546;
_691546 = _691405 + converge_688327;
float _698332;
_698332 = _687514;
float _696009;
_696009 = _682411;
float _696138;
_696138 = _682697;
int _692074;
_692074 = _691933 + converge_688381;
float _696608;
_696608 = _683730;
float _697858;
_697858 = _686470;
float _697273;
_697273 = 6.000000e+00f * _697272;
float _697522;
_697522 = _685732;
float _696179;
_696179 = _682788;
float _697229;
_697229 = 4.000000e+00f * _697228;
float _698168;
_698168 = 6.000000e+00f * _698167;
float _698519;
_698519 = _687926;
float _696359;
_696359 = _696356 + _696358;
float _697725;
_697725 = 6.000000e+00f * _697724;
int _695598;
_695598 = 14 * _695597;
float _697688;
_697688 = 4.000000e+00f * _697687;
float _696566;
_696566 = _683633;
float _696471;
_696471 = 6.000000e+00f * _696470;
int _691406;
_691406 = _691405 + converge_688315;
float _696295;
_696295 = 4.000000e+00f * _696294;
float _695867;
_695867 = _682099;
int _695245;
_695245 = _695104 + converge_688705;
float _697785;
_697785 = _686311;
float _698135;
_698135 = _687080;
float _697060;
_697060 = _684721;
int _693696;
_693696 = converge_688546 * gwidth_681983;
float _695972;
_695972 = _682335;
float _697805;
_697805 = 4.000000e+00f * _697804;
int _694928;
_694928 = converge_688672 * gwidth_681983;
int _693415;
_693415 = _693344 + converge_688519;
float _695863;
_695863 = _682087;
int _688977;
_688977 = _688941 + converge_688066;
float _697049;
_697049 = 6.000000e+00f * _697048;
float _698125;
_698125 = 6.000000e+00f * _698124;
float _698513;
_698513 = _687907;
float _696418;
_696418 = _683312;
float _697986;
_697986 = _686754;
float _698422;
_698422 = _687708;
float _696349;
_696349 = _683161;
float _695921;
_695921 = 6.000000e+00f * _695920;
float _696876;
_696876 = _684314;
float _696873;
_696873 = _684309;
float _697051;
_697051 = _684701;
float _696319;
_696319 = 6.000000e+00f * _696318;
float _696170;
_696170 = _682764;
float _697651;
_697651 = _686017;
float _696404;
_696404 = _683282;
int _691687;
_691687 = _691581 + converge_688342;
float _697694;
_697694 = 4.000000e+00f * _697693;
float _695824;
_695824 = 4.000000e+00f * _695823;
float _696127;
_696127 = _682673;
float _696484;
_696484 = _683458;
int _689575;
_689575 = _689469 + converge_688126;
float _698033;
_698033 = 4.000000e+00f * _698032;
int _695246;
_695246 = 14 * _695245;
float _696158;
_696158 = _682738;
float _696652;
_696652 = 6.000000e+00f * _696651;
float _697018;
_697018 = 4.000000e+00f * _697017;
int _689117;
_689117 = converge_688078 * gwidth_681983;
float _697183;
_697183 = _684992;
float _697234;
_697234 = _685098;
float _698266;
_698266 = 4.000000e+00f * _698265;
int _689083;
_689083 = 14 * _689082;
float _698426;
_698426 = _687720;
float _697876;
_697876 = _686512;
int _690703;
_690703 = 14 * _690702;
float _696032;
_696032 = _682462;
float _698518;
_698518 = _687920;
float _697399;
_697399 = 4.000000e+00f * _697398;
float _697574;
_697574 = _685848;
float _697440;
_697440 = 4.000000e+00f * _697439;
float _696678;
_696678 = 6.000000e+00f * _696677;
float _697987;
_697987 = 6.000000e+00f * _697986;
float _696460;
_696460 = 4.000000e+00f * _696459;
float _697780;
_697780 = 6.000000e+00f * _697779;
int _695527;
_695527 = _695456 + converge_688735;
float _697148;
_697148 = 4.000000e+00f * _697147;
float _696107;
_696107 = _682623;
float _695837;
_695837 = 4.000000e+00f * _695836;
float _698547;
_698547 = _687986;
float _697425;
_697425 = _685521;
float _698055;
_698055 = _686905;
float _698193;
_698193 = _687207;
float _697536;
_697536 = _685762;
float _697750;
_697750 = _686235;
float _698537;
_698537 = 6.000000e+00f * _698536;
float _697379;
_697379 = 4.000000e+00f * _697378;
float _698047;
_698047 = _686885;
float _695979;
_695979 = 4.000000e+00f * _695978;
float _697168;
_697168 = _684956;
float _698395;
_698395 = _687654;
float _695945;
_695945 = _682274;
float _698073;
_698073 = 4.000000e+00f * _698072;
int _691723;
_691723 = 14 * _691722;
int _692285;
_692285 = converge_688402 * gwidth_681983;
float _695831;
_695831 = 4.000000e+00f * _695830;
float _698098;
_698098 = _686996;
int _689505;
_689505 = _689469 + converge_688120;
float _696835;
_696835 = _684223;
float _697295;
_697295 = _685238;
float _697192;
_697192 = _685008;
float _697418;
_697418 = _685504;
float _697270;
_697270 = 4.000000e+00f * _697269;
float _698207;
_698207 = _687237;
float _696166;
_696166 = _682752;
float _698321;
_698321 = _687489;
float _697530;
_697530 = _685751;
float _698532;
_698532 = _687950;
float _695870;
_695870 = _682104;
int _689752;
_689752 = 14 * _689751;
float _696620;
_696620 = 4.000000e+00f * _696619;
float _698080;
_698080 = _686959;
float _697983;
_697983 = _686748;
float _698247;
_698247 = _698244 + _698246;
float _697489;
_697489 = 4.000000e+00f * _697488;
int _694929;
_694929 = _694928 + converge_688675;
float _698173;
_698173 = _687157;
float _696799;
_696799 = 4.000000e+00f * _696798;
float _698252;
_698252 = 4.000000e+00f * _698251;
int _694154;
_694154 = _694048 + converge_688594;
float _695999;
_695999 = _682389;
float _697004;
_697004 = 4.000000e+00f * _697003;
float _697284;
_697284 = _685214;
float _697828;
_697828 = _686402;
int _691125;
_691125 = 14 * _691124;
float _695879;
_695879 = 4.000000e+00f * _695878;
int _693028;
_693028 = _692992 + converge_688480;
float _698464;
_698464 = _687805;
int _691370;
_691370 = _691229 + converge_688309;
float _696847;
_696847 = 4.000000e+00f * _696846;
int _694964;
_694964 = _694928 + converge_688678;
float _696280;
_696280 = _683010;
int _691758;
_691758 = _691757 + converge_688351;
float _696787;
_696787 = 4.000000e+00f * _696786;
float _697803;
_697803 = _686349;
float _696994;
_696994 = _684576;
float _696234;
_696234 = _682909;
float _696273;
_696273 = _682993;
float _697669;
_697669 = _686059;
float _696333;
_696333 = 6.000000e+00f * _696332;
float _696274;
_696274 = _682999;
float _697559;
_697559 = _697556 + _697558;
float _697377;
_697377 = _685413;
float _695890;
_695890 = _682148;
int _689647;
_689647 = 14 * _689646;
int _693661;
_693661 = _693520 + converge_688543;
float _696360;
_696360 = _683186;
int _693346;
_693346 = 14 * _693345;
float _697393;
_697393 = 4.000000e+00f * _697392;
float _696241;
_696241 = 4.000000e+00f * _696240;
float _697508;
_697508 = _685702;
float _696266;
_696266 = _682980;
float _696440;
_696440 = _683356;
float _695895;
_695895 = 6.000000e+00f * _695894;
float _697256;
_697256 = _685147;
float _696082;
_696082 = _682570;
float _695881;
_695881 = _682129;
float _696706;
_696706 = 6.000000e+00f * _696705;
float _698282;
_698282 = _687398;
float _696084;
_696084 = 4.000000e+00f * _696083;
float _697922;
_697922 = _686608;
float _697585;
_697585 = _685872;
float _697220;
_697220 = _685068;
float _696151;
_696151 = _682721;
float _696985;
_696985 = _684555;
float _697230;
_697230 = _697227 + _697229;
float _696531;
_696531 = 4.000000e+00f * _696530;
float _697655;
_697655 = _686029;
float _696476;
_696476 = _683438;
int _692109;
_692109 = converge_688384 * gwidth_681983;
float _696997;
_696997 = _684581;
float _696292;
_696292 = 6.000000e+00f * _696291;
float _697265;
_697265 = _685163;
float _698263;
_698263 = 6.000000e+00f * _698262;
float _698343;
_698343 = _687539;
float _697081;
_697081 = _684767;
int _691969;
_691969 = _691933 + converge_688372;
float _696130;
_696130 = _682678;
float _697309;
_697309 = _685268;
int _690491;
_690491 = 14 * _690490;
float _697710;
_697710 = _686150;
float _698054;
_698054 = _698051 + _698053;
float _696447;
_696447 = _683373;
int _692465;
_692465 = _692464 + converge_688423;
int _694225;
_694225 = _694224 + converge_688603;
float _697615;
_697615 = _685939;
float _698041;
_698041 = _686875;
float _698203;
_698203 = _687225;
int _694542;
_694542 = 14 * _694541;
float _698315;
_698315 = _687479;
float _698409;
_698409 = _687684;
float _697711;
_697711 = 6.000000e+00f * _697710;
float _697347;
_697347 = _685345;
float _696194;
_696194 = 4.000000e+00f * _696193;
float _696250;
_696250 = 6.000000e+00f * _696249;
float _696334;
_696334 = _696331 + _696333;
float _696159;
_696159 = 4.000000e+00f * _696158;
float _696023;
_696023 = _682441;
float _698327;
_698327 = 4.000000e+00f * _698326;
float _697633;
_697633 = _685979;
float _696385;
_696385 = 4.000000e+00f * _696384;
float _696642;
_696642 = _683800;
float _698232;
_698232 = _687286;
float _697915;
_697915 = _686591;
int _689787;
_689787 = 14 * _689786;
int _694260;
_694260 = _694224 + converge_688606;
float _698520;
_698520 = 4.000000e+00f * _698519;
int _695140;
_695140 = _695104 + converge_688696;
int _694190;
_694190 = 14 * _694189;
float _697874;
_697874 = 4.000000e+00f * _697873;
float _697075;
_697075 = _684757;
float _697810;
_697810 = _686366;
float _697476;
_697476 = _685631;
float _697608;
_697608 = _685918;
float _698567;
_698567 = _688027;
float _697487;
_697487 = _685655;
float _696544;
_696544 = _683584;
float _698333;
_698333 = 4.000000e+00f * _698332;
float _696600;
_696600 = _683710;
float _696263;
_696263 = _682975;
float _697483;
_697483 = 4.000000e+00f * _697482;
float _697948;
_697948 = 6.000000e+00f * _697947;
float _696888;
_696888 = 4.000000e+00f * _696887;
float _696488;
_696488 = 4.000000e+00f * _696487;
float _696267;
_696267 = 4.000000e+00f * _696266;
int _689540;
_689540 = _689469 + converge_688123;
float _697545;
_697545 = _685782;
float _697037;
_697037 = _684671;
float _696398;
_696398 = _683271;
float _696826;
_696826 = _684207;
int _692535;
_692535 = _692464 + converge_688429;
float _696152;
_696152 = _682727;
float _697868;
_697868 = _686492;
float _698445;
_698445 = 4.000000e+00f * _698444;
float _696174;
_696174 = 4.000000e+00f * _696173;
float _696579;
_696579 = _683664;
int _692180;
_692180 = _692109 + converge_688393;
float _698175;
_698175 = _687165;
float _696161;
_696161 = _682743;
int _694682;
_694682 = _694576 + converge_688648;
float _697969;
_697969 = _686718;
float _696176;
_696176 = _682774;
int _692711;
_692711 = _692640 + converge_688447;
int _690033;
_690033 = _689997 + converge_688174;
float _697288;
_697288 = 4.000000e+00f * _697287;
float _698171;
_698171 = 4.000000e+00f * _698170;
float _696364;
_696364 = 4.000000e+00f * _696363;
float _697957;
_697957 = _686688;
float _698094;
_698094 = _686984;
float _696567;
_696567 = 4.000000e+00f * _696566;
float _697975;
_697975 = _686729;
float _696732;
_696732 = _684002;
float _696097;
_696097 = _682601;
float _698000;
_698000 = _686784;
float _696448;
_696448 = 4.000000e+00f * _696447;
float _696916;
_696916 = 4.000000e+00f * _696915;
float _696435;
_696435 = _683347;
float _697918;
_697918 = _697915 + _697917;
float _696990;
_696990 = _684564;
float _698104;
_698104 = _687006;
float _697187;
_697187 = 6.000000e+00f * _697186;
float _696659;
_696659 = _683839;
float _697584;
_697584 = _685866;
float _696565;
_696565 = _683627;
float _696680;
_696680 = _683886;
float _696622;
_696622 = _683760;
int _689716;
_689716 = _689645 + converge_688141;
float _696928;
_696928 = _684430;
float _697551;
_697551 = _685793;
float _698185;
_698185 = _687187;
float _697637;
_697637 = _685987;
float _697808;
_697808 = 6.000000e+00f * _697807;
float _698239;
_698239 = _687303;
float _696935;
_696935 = 4.000000e+00f * _696934;
int _695316;
_695316 = _695280 + converge_688714;
float _696551;
_696551 = _683597;
float _698177;
_698177 = 4.000000e+00f * _698176;
float _696040;
_696040 = _682480;
int _690913;
_690913 = _690877 + converge_688264;
float _697848;
_697848 = _686452;
float _698522;
_698522 = _687932;
float _697656;
_697656 = 6.000000e+00f * _697655;
float _697906;
_697906 = 6.000000e+00f * _697905;
float _697109;
_697109 = _684827;
float _696908;
_696908 = _684382;
int _691477;
_691477 = 14 * _691476;
float _696307;
_696307 = 6.000000e+00f * _696306;
float _697259;
_697259 = _685153;
int _695175;
_695175 = _695104 + converge_688699;
float _696976;
_696976 = _684539;
float _697101;
_697101 = 4.000000e+00f * _697100;
int _694507;
_694507 = 14 * _694506;
float _698311;
_698311 = _687467;
float _697162;
_697162 = 4.000000e+00f * _697161;
float _697744;
_697744 = _686220;
float _698478;
_698478 = _687835;
float _696692;
_696692 = 6.000000e+00f * _696691;
float _697845;
_697845 = _686446;
int _692993;
_692993 = _692992 + converge_688477;
float _697026;
_697026 = _684646;
float _697038;
_697038 = 4.000000e+00f * _697037;
float _697668;
_697668 = _697665 + _697667;
int _693274;
_693274 = _693168 + converge_688504;
float _697642;
_697642 = 6.000000e+00f * _697641;
float _697132;
_697132 = _684878;
float _696050;
_696050 = _682502;
float _696344;
_696344 = 4.000000e+00f * _696343;
float _696636;
_696636 = _683790;
float _697113;
_697113 = _684835;
float _697840;
_697840 = _686432;
float _696687;
_696687 = _683899;
float _698487;
_698487 = _687851;
float _696197;
_696197 = 6.000000e+00f * _696196;
int _689470;
_689470 = _689469 + converge_688117;
float _696572;
_696572 = _683644;
float _696523;
_696523 = _683537;
float _698287;
_698287 = _687412;
int _689330;
_689330 = 14 * _689329;
float _697067;
_697067 = 4.000000e+00f * _697066;
float _698066;
_698066 = _686929;
float _697009;
_697009 = _684611;
float _697963;
_697963 = _686699;
int _690421;
_690421 = 14 * _690420;
float _696457;
_696457 = 6.000000e+00f * _696456;
float _696895;
_696895 = _684358;
int _689610;
_689610 = _689469 + converge_688129;
float _698368;
_698368 = _687588;
int _691617;
_691617 = _691581 + converge_688336;
float _696859;
_696859 = 6.000000e+00f * _696858;
float _696632;
_696632 = _683778;
float _697960;
_697960 = _686694;
float _696940;
_696940 = _684460;
float _697714;
_697714 = 4.000000e+00f * _697713;
int _693591;
_693591 = _693520 + converge_688537;
int _690526;
_690526 = _690525 + converge_688225;
int _695458;
_695458 = 14 * _695457;
float _696269;
_696269 = _682985;
float _697730;
_697730 = _686190;
float _696346;
_696346 = _683156;
float _696381;
_696381 = _683227;
float _697973;
_697973 = 6.000000e+00f * _697972;
float _696416;
_696416 = 6.000000e+00f * _696415;
float _696147;
_696147 = _682713;
float _696031;
_696031 = _696028 + _696030;
float _698151;
_698151 = _698148 + _698150;
int _693556;
_693556 = _693520 + converge_688534;
float _697325;
_697325 = _697322 + _697324;
float _696262;
_696262 = _696259 + _696261;
float _697102;
_697102 = _697099 + _697101;
int _690350;
_690350 = _690349 + converge_688207;
float _697249;
_697249 = 4.000000e+00f * _697248;
float _696374;
_696374 = _696371 + _696373;
float _698451;
_698451 = 4.000000e+00f * _698450;
float _697170;
_697170 = 4.000000e+00f * _697169;
float _697592;
_697592 = 4.000000e+00f * _697591;
float _697562;
_697562 = _697559 + _697561;
float _695905;
_695905 = _695902 + _695904;
float _696886;
_696886 = _696883 + _696885;
float _697613;
_697613 = 4.000000e+00f * _697612;
float _696045;
_696045 = 6.000000e+00f * _696044;
float _698563;
_698563 = _698560 + _698562;
float _697366;
_697366 = _697363 + _697365;
int _692817;
_692817 = _692816 + converge_688459;
float _697534;
_697534 = 6.000000e+00f * _697533;
float _698307;
_698307 = 4.000000e+00f * _698306;
int _691194;
_691194 = _691053 + converge_688291;
float _696650;
_696650 = _696647 + _696649;
float _697797;
_697797 = 4.000000e+00f * _697796;
float _697463;
_697463 = _697460 + _697462;
float _698452;
_698452 = _698449 + _698451;
float _696952;
_696952 = 6.000000e+00f * _696951;
int _695562;
_695562 = _695456 + converge_688738;
float _695933;
_695933 = _695930 + _695932;
float _695825;
_695825 = _695821 + _695824;
int _689399;
_689399 = _689293 + converge_688108;
float _696379;
_696379 = 4.000000e+00f * _696378;
float _697420;
_697420 = 4.000000e+00f * _697419;
float _697572;
_697572 = 4.000000e+00f * _697571;
float _697115;
_697115 = 4.000000e+00f * _697114;
float _696114;
_696114 = 6.000000e+00f * _696113;
int _690068;
_690068 = _689997 + converge_688177;
int _690103;
_690103 = _689997 + converge_688180;
float _696621;
_696621 = _696618 + _696620;
float _695962;
_695962 = _695959 + _695961;
int _693309;
_693309 = _693168 + converge_688507;
int _689047;
_689047 = _688941 + converge_688072;
int _689012;
_689012 = _688941 + converge_688069;
float _697088;
_697088 = _697085 + _697087;
float _696790;
_696790 = 6.000000e+00f * _696789;
float _695918;
_695918 = 4.000000e+00f * _695917;
float _695880;
_695880 = _695877 + _695879;
float _696071;
_696071 = _696068 + _696070;
float _696936;
_696936 = _696933 + _696935;
int _690878;
_690878 = _690877 + converge_688261;
float _697783;
_697783 = 4.000000e+00f * _697782;
float _696924;
_696924 = _696921 + _696923;
float _696062;
_696062 = 4.000000e+00f * _696061;
int _693450;
_693450 = _693344 + converge_688522;
float _698222;
_698222 = 6.000000e+00f * _698221;
float _698030;
_698030 = 6.000000e+00f * _698029;
int _693381;
_693381 = 14 * _693380;
float _698234;
_698234 = 4.000000e+00f * _698233;
float _698494;
_698494 = _698491 + _698493;
float _697606;
_697606 = 4.000000e+00f * _697605;
float _696950;
_696950 = _696947 + _696949;
float _695893;
_695893 = _695890 + _695892;
float _696788;
_696788 = _696785 + _696787;
float _696145;
_696145 = 4.000000e+00f * _696144;
float _696056;
_696056 = 4.000000e+00f * _696055;
float _696719;
_696719 = _696716 + _696718;
float _696018;
_696018 = 6.000000e+00f * _696017;
float _696125;
_696125 = 4.000000e+00f * _696124;
float _697645;
_697645 = 4.000000e+00f * _697644;
float _697434;
_697434 = 4.000000e+00f * _697433;
float _695952;
_695952 = 4.000000e+00f * _695951;
float _698424;
_698424 = 4.000000e+00f * _698423;
float _696868;
_696868 = 4.000000e+00f * _696867;
float _698084;
_698084 = 6.000000e+00f * _698083;
float _696345;
_696345 = _696342 + _696344;
float _697904;
_697904 = _697901 + _697903;
float _697451;
_697451 = 6.000000e+00f * _697450;
float _698442;
_698442 = 6.000000e+00f * _698441;
float _698535;
_698535 = _698532 + _698534;
int _692888;
_692888 = 14 * _692887;
float _696842;
_696842 = _696839 + _696841;
float _697820;
_697820 = 4.000000e+00f * _697819;
float _697495;
_697495 = 4.000000e+00f * _697494;
float _697340;
_697340 = _697337 + _697339;
int _691055;
_691055 = 14 * _691054;
float _696290;
_696290 = _696287 + _696289;
float _696695;
_696695 = 4.000000e+00f * _696694;
float _696468;
_696468 = 4.000000e+00f * _696467;
float _697033;
_697033 = _697030 + _697032;
float _697945;
_697945 = 4.000000e+00f * _697944;
float _698482;
_698482 = 6.000000e+00f * _698481;
float _697737;
_697737 = _697734 + _697736;
float _697739;
_697739 = 6.000000e+00f * _697738;
float _698028;
_698028 = _698025 + _698027;
float _697517;
_697517 = 4.000000e+00f * _697516;
float _698361;
_698361 = 4.000000e+00f * _698360;
float _697659;
_697659 = 4.000000e+00f * _697658;
float _697682;
_697682 = 4.000000e+00f * _697681;
int _690561;
_690561 = _690525 + converge_688228;
int _690631;
_690631 = _690525 + converge_688234;
int _690596;
_690596 = _690525 + converge_688231;
int _690666;
_690666 = _690525 + converge_688237;
float _697468;
_697468 = 4.000000e+00f * _697467;
float _696676;
_696676 = _696673 + _696675;
float _696200;
_696200 = 4.000000e+00f * _696199;
int _691441;
_691441 = _691405 + converge_688318;
float _697951;
_697951 = 4.000000e+00f * _697950;
float _696817;
_696817 = _696814 + _696816;
float _697203;
_697203 = 4.000000e+00f * _697202;
int _694437;
_694437 = 14 * _694436;
float _696209;
_696209 = _696206 + _696208;
float _696963;
_696963 = 4.000000e+00f * _696962;
float _697863;
_697863 = 6.000000e+00f * _697862;
float _696519;
_696519 = 4.000000e+00f * _696518;
float _697628;
_697628 = 6.000000e+00f * _697627;
float _697764;
_697764 = _697761 + _697763;
float _695919;
_695919 = _695916 + _695918;
float _697589;
_697589 = 6.000000e+00f * _697588;
float _697625;
_697625 = 4.000000e+00f * _697624;
int _692958;
_692958 = 14 * _692957;
float _696775;
_696775 = 6.000000e+00f * _696774;
float _695935;
_695935 = 6.000000e+00f * _695934;
float _698045;
_698045 = 4.000000e+00f * _698044;
int _690842;
_690842 = _690701 + converge_688255;
int _690737;
_690737 = _690701 + converge_688246;
int _690772;
_690772 = _690701 + converge_688249;
float _696057;
_696057 = _696054 + _696056;
float _696993;
_696993 = _696990 + _696992;
float _696539;
_696539 = 4.000000e+00f * _696538;
float _696805;
_696805 = 4.000000e+00f * _696804;
float _698454;
_698454 = 6.000000e+00f * _698453;
float _697791;
_697791 = 4.000000e+00f * _697790;
float _697136;
_697136 = 4.000000e+00f * _697135;
float _698382;
_698382 = 4.000000e+00f * _698381;
float _696248;
_696248 = _696245 + _696247;
int _693205;
_693205 = 14 * _693204;
float _696869;
_696869 = _696866 + _696868;
float _698355;
_698355 = 4.000000e+00f * _698354;
float _698250;
_698250 = _698247 + _698249;
float _696428;
_696428 = _696425 + _696427;
float _698197;
_698197 = 4.000000e+00f * _698196;
float _698211;
_698211 = 4.000000e+00f * _698210;
int _690984;
_690984 = 14 * _690983;
float _697700;
_697700 = 4.000000e+00f * _697699;
float _697299;
_697299 = 6.000000e+00f * _697298;
float _698220;
_698220 = _698217 + _698219;
float _696117;
_696117 = 4.000000e+00f * _696116;
float _697005;
_697005 = _697002 + _697004;
float _696745;
_696745 = _696742 + _696744;
float _697603;
_697603 = 6.000000e+00f * _697602;
float _696183;
_696183 = 6.000000e+00f * _696182;
float _696983;
_696983 = 4.000000e+00f * _696982;
float _696731;
_696731 = _696728 + _696730;
int _694365;
_694365 = _694224 + converge_688615;
int _694330;
_694330 = _694224 + converge_688612;
float _697833;
_697833 = _697830 + _697832;
float _698328;
_698328 = _698325 + _698327;
int _690808;
_690808 = 14 * _690807;
float _697639;
_697639 = 4.000000e+00f * _697638;
float _697019;
_697019 = _697016 + _697018;
float _698331;
_698331 = _698328 + _698330;
float _697330;
_697330 = 4.000000e+00f * _697329;
float _698457;
_698457 = 4.000000e+00f * _698456;
float _697243;
_697243 = 4.000000e+00f * _697242;
float _696433;
_696433 = 4.000000e+00f * _696432;
float _696212;
_696212 = _696209 + _696211;
float _698370;
_698370 = 4.000000e+00f * _698369;
float _696955;
_696955 = 4.000000e+00f * _696954;
float _696514;
_696514 = _696511 + _696513;
float _696758;
_696758 = 4.000000e+00f * _696757;
float _696195;
_696195 = _696192 + _696194;
float _696871;
_696871 = 6.000000e+00f * _696870;
int _688836;
_688836 = _688761 + converge_688051;
int _688762;
_688762 = _688761 + converge_688045;
int _688871;
_688871 = _688761 + converge_688054;
int _688801;
_688801 = _688761 + converge_688048;
float _696142;
_696142 = 6.000000e+00f * _696141;
float _697118;
_697118 = 6.000000e+00f * _697117;
float _697998;
_697998 = 4.000000e+00f * _697997;
float _697313;
_697313 = 6.000000e+00f * _697312;
int _693133;
_693133 = _692992 + converge_688489;
float _695885;
_695885 = 4.000000e+00f * _695884;
float _696655;
_696655 = 4.000000e+00f * _696654;
float _698358;
_698358 = 6.000000e+00f * _698357;
float _697838;
_697838 = 4.000000e+00f * _697837;
int _694119;
_694119 = _694048 + converge_688591;
int _694049;
_694049 = _694048 + converge_688585;
float _696800;
_696800 = _696797 + _696799;
float _696214;
_696214 = 4.000000e+00f * _696213;
float _697573;
_697573 = _697570 + _697572;
float _697215;
_697215 = 4.000000e+00f * _697214;
float _698526;
_698526 = 4.000000e+00f * _698525;
float _697466;
_697466 = _697463 + _697465;
float _697204;
_697204 = _697201 + _697203;
float _697047;
_697047 = _697044 + _697046;
float _697263;
_697263 = 4.000000e+00f * _697262;
int _690209;
_690209 = _690173 + converge_688192;
float _697875;
_697875 = _697872 + _697874;
float _696667;
_696667 = 4.000000e+00f * _696666;
float _696911;
_696911 = _696908 + _696910;
float _696640;
_696640 = 4.000000e+00f * _696639;
float _697093;
_697093 = 4.000000e+00f * _697092;
int _691160;
_691160 = 14 * _691159;
int _691019;
_691019 = 14 * _691018;
float _697695;
_697695 = _697692 + _697694;
float _698319;
_698319 = 4.000000e+00f * _698318;
int _690245;
_690245 = 14 * _690244;
float _696634;
_696634 = 4.000000e+00f * _696633;
float _698154;
_698154 = _698151 + _698153;
int _691898;
_691898 = _691757 + converge_688363;
int _691863;
_691863 = _691757 + converge_688360;
int _691828;
_691828 = _691757 + converge_688357;
float _697722;
_697722 = 4.000000e+00f * _697721;
float _696112;
_696112 = _696109 + _696111;
float _698237;
_698237 = 6.000000e+00f * _698236;
float _696845;
_696845 = _696842 + _696844;
int _694613;
_694613 = 14 * _694612;
float _698166;
_698166 = _698163 + _698165;
float _697892;
_697892 = _697889 + _697891;
float _697233;
_697233 = _697230 + _697232;
float _697932;
_697932 = _697929 + _697931;
float _695987;
_695987 = 4.000000e+00f * _695986;
float _697454;
_697454 = 4.000000e+00f * _697453;
float _697382;
_697382 = 6.000000e+00f * _697381;
float _696902;
_696902 = 4.000000e+00f * _696901;
float _697880;
_697880 = 4.000000e+00f * _697879;
float _698012;
_698012 = 4.000000e+00f * _698011;
float _697423;
_697423 = 6.000000e+00f * _697422;
float _697394;
_697394 = _697391 + _697393;
float _697821;
_697821 = _697818 + _697820;
float _697107;
_697107 = 4.000000e+00f * _697106;
float _695851;
_695851 = 4.000000e+00f * _695850;
float _697578;
_697578 = 4.000000e+00f * _697577;
float _698304;
_698304 = 6.000000e+00f * _698303;
int _693522;
_693522 = 14 * _693521;
float yf_695815;
yf_695815 = _695813 / 8.000000e+00f;
float _697142;
_697142 = 4.000000e+00f * _697141;
float _696499;
_696499 = 6.000000e+00f * _696498;
float _696516;
_696516 = 6.000000e+00f * _696515;
float _697130;
_697130 = 4.000000e+00f * _697129;
float _697708;
_697708 = 4.000000e+00f * _697707;
float _697654;
_697654 = _697651 + _697653;
float _698122;
_698122 = 4.000000e+00f * _698121;
float _697518;
_697518 = _697515 + _697517;
float _697937;
_697937 = 4.000000e+00f * _697936;
float _698496;
_698496 = 6.000000e+00f * _698495;
float _696042;
_696042 = 4.000000e+00f * _696041;
float _696606;
_696606 = 4.000000e+00f * _696605;
float _695838;
_695838 = _695835 + _695837;
float _696386;
_696386 = _696383 + _696385;
float _697826;
_697826 = 4.000000e+00f * _697825;
float _698439;
_698439 = 4.000000e+00f * _698438;
float _697021;
_697021 = 6.000000e+00f * _697020;
float _697091;
_697091 = _697088 + _697090;
int _688907;
_688907 = 14 * _688906;
float _696073;
_696073 = 6.000000e+00f * _696072;
int _694753;
_694753 = _694752 + converge_688657;
int _694893;
_694893 = _694752 + converge_688669;
int _694085;
_694085 = 14 * _694084;
float _697549;
_697549 = 6.000000e+00f * _697548;
float _696036;
_696036 = 4.000000e+00f * _696035;
float _695938;
_695938 = 4.000000e+00f * _695937;
float _696703;
_696703 = 4.000000e+00f * _696702;
float _697276;
_697276 = 4.000000e+00f * _697275;
int _692005;
_692005 = 14 * _692004;
int _693064;
_693064 = 14 * _693063;
float _697368;
_697368 = 6.000000e+00f * _697367;
float _696586;
_696586 = 4.000000e+00f * _696585;
int _695351;
_695351 = _695280 + converge_688717;
int _695281;
_695281 = _695280 + converge_688711;
float _696540;
_696540 = _696537 + _696539;
int _692853;
_692853 = 14 * _692852;
int zi_688765;
zi_688765 = (int)zv_688764;
float _698508;
_698508 = 4.000000e+00f * _698507;
int _691582;
_691582 = _691581 + converge_688333;
int _691652;
_691652 = _691581 + converge_688339;
int _693627;
_693627 = 14 * _693626;
float _696542;
_696542 = 6.000000e+00f * _696541;
float _695854;
_695854 = 6.000000e+00f * _695853;
float _696607;
_696607 = _696604 + _696606;
int _691935;
_691935 = 14 * _691934;
float _697860;
_697860 = 4.000000e+00f * _697859;
float _697357;
_697357 = 4.000000e+00f * _697356;
float _697159;
_697159 = 6.000000e+00f * _697158;
float _695857;
_695857 = 4.000000e+00f * _695856;
float _698205;
_698205 = 4.000000e+00f * _698204;
float _697105;
_697105 = _697102 + _697104;
float _698192;
_698192 = _698189 + _698191;
float _697302;
_697302 = 4.000000e+00f * _697301;
int _695738;
_695738 = _695632 + converge_688756;
int _695703;
_695703 = _695632 + converge_688753;
int _695668;
_695668 = _695632 + converge_688750;
int _695773;
_695773 = _695632 + converge_688759;
float _696689;
_696689 = 4.000000e+00f * _696688;
float _696528;
_696528 = 6.000000e+00f * _696527;
float _696661;
_696661 = 4.000000e+00f * _696660;
float _698264;
_698264 = _698261 + _698263;
float _696377;
_696377 = _696374 + _696376;
float _696322;
_696322 = 4.000000e+00f * _696321;
float _696059;
_696059 = 6.000000e+00f * _696058;
float _697852;
_697852 = 4.000000e+00f * _697851;
float _695865;
_695865 = 4.000000e+00f * _695864;
float _696413;
_696413 = 4.000000e+00f * _696412;
int _690386;
_690386 = 14 * _690385;
float _697503;
_697503 = 4.000000e+00f * _697502;
float _698070;
_698070 = 6.000000e+00f * _698069;
float xf_695819;
xf_695819 = _695818 / 8.000000e+00f;
int _693908;
_693908 = _693872 + converge_688570;
int _693873;
_693873 = _693872 + converge_688567;
int _693943;
_693943 = _693872 + converge_688573;
int _694013;
_694013 = _693872 + converge_688579;
int _693978;
_693978 = _693872 + converge_688576;
int _689892;
_689892 = _689821 + converge_688159;
int _689857;
_689857 = _689821 + converge_688156;
int _689822;
_689822 = _689821 + converge_688153;
int _689962;
_689962 = _689821 + converge_688165;
int _689927;
_689927 = _689821 + converge_688162;
float _698109;
_698109 = _698106 + _698108;
float _697073;
_697073 = 4.000000e+00f * _697072;
float _697035;
_697035 = 6.000000e+00f * _697034;
int _690139;
_690139 = 14 * _690138;
float _698225;
_698225 = 4.000000e+00f * _698224;
float _696099;
_696099 = 4.000000e+00f * _696098;
float _697754;
_697754 = 6.000000e+00f * _697753;
float _696759;
_696759 = _696756 + _696758;
float _696748;
_696748 = _696745 + _696747;
int _690175;
_690175 = 14 * _690174;
float _696048;
_696048 = 4.000000e+00f * _696047;
float _696856;
_696856 = 4.000000e+00f * _696855;
float _696090;
_696090 = 4.000000e+00f * _696089;
float _695898;
_695898 = 4.000000e+00f * _695897;
float _696004;
_696004 = 6.000000e+00f * _696003;
float _696430;
_696430 = 6.000000e+00f * _696429;
float _698314;
_698314 = _698311 + _698313;
float _696316;
_696316 = 4.000000e+00f * _696315;
float _696819;
_696819 = 4.000000e+00f * _696818;
float _697397;
_697397 = _697394 + _697396;
float _696525;
_696525 = 4.000000e+00f * _696524;
int _691794;
_691794 = 14 * _691793;
float _697355;
_697355 = _697352 + _697354;
float _696966;
_696966 = 6.000000e+00f * _696965;
float _696724;
_696724 = 4.000000e+00f * _696723;
float _697601;
_697601 = _697598 + _697600;
float _696593;
_696593 = _696590 + _696592;
float _696454;
_696454 = 4.000000e+00f * _696453;
int _689682;
_689682 = 14 * _689681;
int _694824;
_694824 = 14 * _694823;
int _692781;
_692781 = _692640 + converge_688453;
int _692746;
_692746 = _692640 + converge_688450;
int _692641;
_692641 = _692640 + converge_688441;
int _692676;
_692676 = _692640 + converge_688444;
int _693099;
_693099 = 14 * _693098;
float _697409;
_697409 = _697406 + _697408;
int _695105;
_695105 = _695104 + converge_688693;
int _695210;
_695210 = _695104 + converge_688702;
float _697792;
_697792 = _697789 + _697791;
float _698039;
_698039 = 4.000000e+00f * _698038;
float _696722;
_696722 = _696719 + _696721;
float _696482;
_696482 = 4.000000e+00f * _696481;
float _696914;
_696914 = _696911 + _696913;
float _698274;
_698274 = 4.000000e+00f * _698273;
int _691230;
_691230 = _691229 + converge_688297;
int _691335;
_691335 = _691229 + converge_688306;
int _691300;
_691300 = _691229 + converge_688303;
float _695840;
_695840 = 6.000000e+00f * _695839;
float _698097;
_698097 = _698094 + _698096;
float _698142;
_698142 = 4.000000e+00f * _698141;
int _692500;
_692500 = _692464 + converge_688426;
int _692570;
_692570 = _692464 + converge_688432;
int _692605;
_692605 = _692464 + converge_688435;
float _697327;
_697327 = 6.000000e+00f * _697326;
float _698275;
_698275 = _698272 + _698274;
int _693255;
_693255 = _693240 + zi_688765;
float _697504;
_697504 = _697501 + _697503;
int _695387;
_695387 = 14 * _695386;
int _694402;
_694402 = 14 * _694401;
float _696927;
_696927 = _696924 + _696926;
float _695908;
_695908 = _695905 + _695907;
int _692923;
_692923 = 14 * _692922;
float _698383;
_698383 = _698380 + _698382;
int _689295;
_689295 = 14 * _689294;
float _698157;
_698157 = _698154 + _698156;
int _689365;
_689365 = 14 * _689364;
float _698015;
_698015 = 6.000000e+00f * _698014;
float _696087;
_696087 = 6.000000e+00f * _696086;
float _697777;
_697777 = 4.000000e+00f * _697776;
float _697564;
_697564 = 4.000000e+00f * _697563;
float _697614;
_697614 = _697611 + _697613;
int _690949;
_690949 = 14 * _690948;
int _691105;
_691105 = _691090 + zi_688765;
float _696612;
_696612 = 4.000000e+00f * _696611;
int _694859;
_694859 = 14 * _694858;
int _694733;
_694733 = _694718 + zi_688765;
float _697342;
_697342 = 6.000000e+00f * _697341;
float _697216;
_697216 = _697213 + _697215;
float _698385;
_698385 = 6.000000e+00f * _698384;
int _690280;
_690280 = 14 * _690279;
float _696007;
_696007 = 4.000000e+00f * _696006;
float _698087;
_698087 = 4.000000e+00f * _698086;
float _697673;
_697673 = 4.000000e+00f * _697672;
float _696570;
_696570 = 6.000000e+00f * _696569;
int _695634;
_695634 = 14 * _695633;
float _698111;
_698111 = 6.000000e+00f * _698110;
float _696156;
_696156 = 6.000000e+00f * _696155;
float _697920;
_697920 = 6.000000e+00f * _697919;
int _691512;
_691512 = 14 * _691511;
float _698565;
_698565 = 6.000000e+00f * _698564;
int _688943;
_688943 = 14 * _688942;
float _696388;
_696388 = 6.000000e+00f * _696387;
float _698114;
_698114 = 4.000000e+00f * _698113;
int _695508;
_695508 = _695493 + zi_688765;
int _692040;
_692040 = 14 * _692039;
float _698291;
_698291 = 6.000000e+00f * _698290;
float _696554;
_696554 = _696551 + _696553;
float _696751;
_696751 = _696748 + _696750;
float _697766;
_697766 = 6.000000e+00f * _697765;
float _696776;
_696776 = _696773 + _696775;
int _695422;
_695422 = 14 * _695421;
float _696442;
_696442 = 4.000000e+00f * _696441;
float _696595;
_696595 = 6.000000e+00f * _696594;
float _696308;
_696308 = _696305 + _696307;
int _690471;
_690471 = _690456 + zi_688765;
float _697823;
_697823 = 6.000000e+00f * _697822;
float _697207;
_697207 = _697204 + _697206;
int _694789;
_694789 = 14 * _694788;
int _690315;
_690315 = 14 * _690314;
float _696938;
_696938 = 6.000000e+00f * _696937;
int _694311;
_694311 = _694296 + zi_688765;
float _696222;
_696222 = 4.000000e+00f * _696221;
float _698468;
_698468 = 6.000000e+00f * _698467;
int _691266;
_691266 = 14 * _691265;
float _696337;
_696337 = _696334 + _696336;
float _697271;
_697271 = _697268 + _697270;
float _695965;
_695965 = _695962 + _695964;
float _696168;
_696168 = 4.000000e+00f * _696167;
float _696001;
_696001 = 4.000000e+00f * _696000;
float _696500;
_696500 = _696497 + _696499;
float _697794;
_697794 = 6.000000e+00f * _697793;
float _698040;
_698040 = _698037 + _698039;
float _698402;
_698402 = 4.000000e+00f * _698401;
float _696015;
_696015 = 4.000000e+00f * _696014;
int _689435;
_689435 = 14 * _689434;
float _697448;
_697448 = 4.000000e+00f * _697447;
float _698356;
_698356 = _698353 + _698355;
int _691547;
_691547 = 14 * _691546;
float _696139;
_696139 = 4.000000e+00f * _696138;
int _692075;
_692075 = 14 * _692074;
float _696609;
_696609 = 6.000000e+00f * _696608;
float _697861;
_697861 = _697858 + _697860;
float _697274;
_697274 = _697271 + _697273;
float _697523;
_697523 = 4.000000e+00f * _697522;
float _696180;
_696180 = 4.000000e+00f * _696179;
float _698169;
_698169 = _698166 + _698168;
int _695613;
_695613 = _695598 + zi_688765;
int _691407;
_691407 = 14 * _691406;
float _695868;
_695868 = 6.000000e+00f * _695867;
float _698136;
_698136 = 4.000000e+00f * _698135;
float _697061;
_697061 = 4.000000e+00f * _697060;
int _693697;
_693697 = _693696 + converge_688549;
int _693767;
_693767 = _693696 + converge_688555;
int _693802;
_693802 = _693696 + converge_688558;
int _693732;
_693732 = _693696 + converge_688552;
int _693837;
_693837 = _693696 + converge_688561;
float _695973;
_695973 = 4.000000e+00f * _695972;
float _697806;
_697806 = _697803 + _697805;
int _694999;
_694999 = _694928 + converge_688681;
int _695069;
_695069 = _694928 + converge_688687;
int _695034;
_695034 = _694928 + converge_688684;
int _693416;
_693416 = 14 * _693415;
float _695866;
_695866 = _695863 + _695865;
int _688978;
_688978 = 14 * _688977;
float _697050;
_697050 = _697047 + _697049;
float _698514;
_698514 = 4.000000e+00f * _698513;
float _696419;
_696419 = 4.000000e+00f * _696418;
float _698425;
_698425 = _698422 + _698424;
float _696350;
_696350 = 4.000000e+00f * _696349;
float _695922;
_695922 = _695919 + _695921;
float _696874;
_696874 = 4.000000e+00f * _696873;
float _697052;
_697052 = 4.000000e+00f * _697051;
float _696171;
_696171 = 6.000000e+00f * _696170;
float _696405;
_696405 = 4.000000e+00f * _696404;
int _691688;
_691688 = 14 * _691687;
float _696128;
_696128 = 6.000000e+00f * _696127;
float _696485;
_696485 = 6.000000e+00f * _696484;
int _689576;
_689576 = 14 * _689575;
int _695261;
_695261 = _695246 + zi_688765;
float _696653;
_696653 = _696650 + _696652;
int _689153;
_689153 = _689117 + converge_688084;
int _689258;
_689258 = _689117 + converge_688093;
int _689188;
_689188 = _689117 + converge_688087;
int _689223;
_689223 = _689117 + converge_688090;
int _689118;
_689118 = _689117 + converge_688081;
float _697184;
_697184 = 4.000000e+00f * _697183;
float _697235;
_697235 = 4.000000e+00f * _697234;
float _698267;
_698267 = _698264 + _698266;
int _689098;
_689098 = _689083 + zi_688765;
float _698427;
_698427 = 6.000000e+00f * _698426;
float _697877;
_697877 = 6.000000e+00f * _697876;
int _690718;
_690718 = _690703 + zi_688765;
float _696033;
_696033 = 6.000000e+00f * _696032;
float _698521;
_698521 = _698518 + _698520;
float _697400;
_697400 = _697397 + _697399;
float _697575;
_697575 = 6.000000e+00f * _697574;
float _696679;
_696679 = _696676 + _696678;
int _695528;
_695528 = 14 * _695527;
float _698548;
_698548 = 4.000000e+00f * _698547;
float _697426;
_697426 = 4.000000e+00f * _697425;
float _698056;
_698056 = 6.000000e+00f * _698055;
float _698194;
_698194 = 6.000000e+00f * _698193;
float _697537;
_697537 = 4.000000e+00f * _697536;
float _697751;
_697751 = 4.000000e+00f * _697750;
float _698538;
_698538 = _698535 + _698537;
float _697380;
_697380 = _697377 + _697379;
float _697171;
_697171 = _697168 + _697170;
float _698396;
_698396 = 4.000000e+00f * _698395;
float _695946;
_695946 = 4.000000e+00f * _695945;
int _691738;
_691738 = _691723 + zi_688765;
int _692429;
_692429 = _692285 + converge_688417;
int _692394;
_692394 = _692285 + converge_688414;
int _692286;
_692286 = _692285 + converge_688405;
int _692359;
_692359 = _692285 + converge_688411;
int _692324;
_692324 = _692285 + converge_688408;
float _698099;
_698099 = 6.000000e+00f * _698098;
int _689506;
_689506 = 14 * _689505;
float _697296;
_697296 = 4.000000e+00f * _697295;
float _697421;
_697421 = _697418 + _697420;
float _698208;
_698208 = 6.000000e+00f * _698207;
float _696169;
_696169 = _696166 + _696168;
float _697531;
_697531 = 4.000000e+00f * _697530;
float _695871;
_695871 = 4.000000e+00f * _695870;
int _689767;
_689767 = _689752 + zi_688765;
float _698081;
_698081 = 4.000000e+00f * _698080;
float _697984;
_697984 = 4.000000e+00f * _697983;
float _697490;
_697490 = _697487 + _697489;
int _694930;
_694930 = 14 * _694929;
float _698253;
_698253 = _698250 + _698252;
int _694155;
_694155 = 14 * _694154;
float _696002;
_696002 = _695999 + _696001;
float _697285;
_697285 = 6.000000e+00f * _697284;
int _691140;
_691140 = _691125 + zi_688765;
int _693029;
_693029 = 14 * _693028;
float _698465;
_698465 = 4.000000e+00f * _698464;
int _691371;
_691371 = 14 * _691370;
float _696848;
_696848 = _696845 + _696847;
int _694965;
_694965 = 14 * _694964;
float _696281;
_696281 = 4.000000e+00f * _696280;
int _691759;
_691759 = 14 * _691758;
float _696995;
_696995 = 6.000000e+00f * _696994;
float _696235;
_696235 = 4.000000e+00f * _696234;
float _697670;
_697670 = 6.000000e+00f * _697669;
float _696275;
_696275 = 4.000000e+00f * _696274;
int _689662;
_689662 = _689647 + zi_688765;
int _693662;
_693662 = 14 * _693661;
float _696361;
_696361 = 6.000000e+00f * _696360;
int _693361;
_693361 = _693346 + zi_688765;
float _697509;
_697509 = 4.000000e+00f * _697508;
float _696443;
_696443 = _696440 + _696442;
float _695896;
_695896 = _695893 + _695895;
float _697257;
_697257 = 4.000000e+00f * _697256;
float _696085;
_696085 = _696082 + _696084;
float _695882;
_695882 = 6.000000e+00f * _695881;
float _697923;
_697923 = 4.000000e+00f * _697922;
float _697586;
_697586 = 4.000000e+00f * _697585;
float _697221;
_697221 = 4.000000e+00f * _697220;
int _692215;
_692215 = _692109 + converge_688396;
int _692250;
_692250 = _692109 + converge_688399;
int _692145;
_692145 = _692109 + converge_688390;
int _692110;
_692110 = _692109 + converge_688387;
float _696998;
_696998 = 4.000000e+00f * _696997;
float _696293;
_696293 = _696290 + _696292;
float _698344;
_698344 = 6.000000e+00f * _698343;
int _691970;
_691970 = 14 * _691969;
float _696131;
_696131 = 4.000000e+00f * _696130;
float _697310;
_697310 = 4.000000e+00f * _697309;
int _690506;
_690506 = _690491 + zi_688765;
float _698057;
_698057 = _698054 + _698056;
int _692466;
_692466 = 14 * _692465;
int _694226;
_694226 = 14 * _694225;
float _697616;
_697616 = 6.000000e+00f * _697615;
float _698042;
_698042 = 6.000000e+00f * _698041;
float _698206;
_698206 = _698203 + _698205;
int _694557;
_694557 = _694542 + zi_688765;
float _698316;
_698316 = 6.000000e+00f * _698315;
float _698410;
_698410 = 4.000000e+00f * _698409;
float _696251;
_696251 = _696248 + _696250;
float _698235;
_698235 = _698232 + _698234;
int _689802;
_689802 = _689787 + zi_688765;
int _694261;
_694261 = 14 * _694260;
int _695141;
_695141 = 14 * _695140;
int _694205;
_694205 = _694190 + zi_688765;
float _697076;
_697076 = 6.000000e+00f * _697075;
float _697811;
_697811 = 4.000000e+00f * _697810;
float _697477;
_697477 = 4.000000e+00f * _697476;
float _698568;
_698568 = 4.000000e+00f * _698567;
float _696545;
_696545 = 4.000000e+00f * _696544;
float _698334;
_698334 = _698331 + _698333;
float _696264;
_696264 = 6.000000e+00f * _696263;
float _696889;
_696889 = _696886 + _696888;
int _689541;
_689541 = 14 * _689540;
float _697546;
_697546 = 4.000000e+00f * _697545;
float _696399;
_696399 = 4.000000e+00f * _696398;
float _696827;
_696827 = 4.000000e+00f * _696826;
int _692536;
_692536 = 14 * _692535;
float _696153;
_696153 = 4.000000e+00f * _696152;
float _696580;
_696580 = 4.000000e+00f * _696579;
int _692181;
_692181 = 14 * _692180;
float _698178;
_698178 = _698175 + _698177;
int _694683;
_694683 = 14 * _694682;
float _697970;
_697970 = 4.000000e+00f * _697969;
int _692712;
_692712 = 14 * _692711;
int _690034;
_690034 = 14 * _690033;
float _698172;
_698172 = _698169 + _698171;
float _697958;
_697958 = 4.000000e+00f * _697957;
float _696568;
_696568 = _696565 + _696567;
float _697976;
_697976 = 4.000000e+00f * _697975;
float _696733;
_696733 = 6.000000e+00f * _696732;
float _696100;
_696100 = _696097 + _696099;
float _698001;
_698001 = 6.000000e+00f * _698000;
float _696917;
_696917 = _696914 + _696916;
float _697921;
_697921 = _697918 + _697920;
float _696662;
_696662 = _696659 + _696661;
float _697587;
_697587 = _697584 + _697586;
float _696681;
_696681 = 4.000000e+00f * _696680;
float _696623;
_696623 = 6.000000e+00f * _696622;
int _689717;
_689717 = 14 * _689716;
float _696929;
_696929 = 4.000000e+00f * _696928;
float _697552;
_697552 = 4.000000e+00f * _697551;
float _697640;
_697640 = _697637 + _697639;
float _697809;
_697809 = _697806 + _697808;
float _698240;
_698240 = 4.000000e+00f * _698239;
int _695317;
_695317 = 14 * _695316;
float _696043;
_696043 = _696040 + _696042;
int _690914;
_690914 = 14 * _690913;
float _697849;
_697849 = 6.000000e+00f * _697848;
float _698523;
_698523 = 6.000000e+00f * _698522;
float _697657;
_697657 = _697654 + _697656;
float _697907;
_697907 = _697904 + _697906;
int _691492;
_691492 = _691477 + zi_688765;
float _697260;
_697260 = 6.000000e+00f * _697259;
int _695176;
_695176 = 14 * _695175;
float _696977;
_696977 = 4.000000e+00f * _696976;
int _694522;
_694522 = _694507 + zi_688765;
float _698479;
_698479 = 4.000000e+00f * _698478;
float _697846;
_697846 = 4.000000e+00f * _697845;
int _692994;
_692994 = 14 * _692993;
float _697671;
_697671 = _697668 + _697670;
int _693275;
_693275 = 14 * _693274;
float _697643;
_697643 = _697640 + _697642;
float _697133;
_697133 = 6.000000e+00f * _697132;
float _696637;
_696637 = 6.000000e+00f * _696636;
float _697116;
_697116 = _697113 + _697115;
float _696690;
_696690 = _696687 + _696689;
float _696198;
_696198 = _696195 + _696197;
int _689471;
_689471 = 14 * _689470;
float _696573;
_696573 = 4.000000e+00f * _696572;
float _696526;
_696526 = _696523 + _696525;
float _698288;
_698288 = 4.000000e+00f * _698287;
int _689345;
_689345 = _689330 + zi_688765;
float _698067;
_698067 = 4.000000e+00f * _698066;
float _697010;
_697010 = 4.000000e+00f * _697009;
float _697964;
_697964 = 4.000000e+00f * _697963;
int _690436;
_690436 = _690421 + zi_688765;
float _696896;
_696896 = 4.000000e+00f * _696895;
int _689611;
_689611 = 14 * _689610;
float _698371;
_698371 = _698368 + _698370;
int _691618;
_691618 = 14 * _691617;
float _696635;
_696635 = _696632 + _696634;
float _697961;
_697961 = 6.000000e+00f * _697960;
float _696941;
_696941 = 4.000000e+00f * _696940;
int _693592;
_693592 = 14 * _693591;
int _690527;
_690527 = 14 * _690526;
int _695473;
_695473 = _695458 + zi_688765;
float _696347;
_696347 = 6.000000e+00f * _696346;
float _696034;
_696034 = _696031 + _696033;
int _693557;
_693557 = 14 * _693556;
float _697328;
_697328 = _697325 + _697327;
float _696265;
_696265 = _696262 + _696264;
int _690351;
_690351 = 14 * _690350;
float _697565;
_697565 = _697562 + _697564;
float _696046;
_696046 = _696043 + _696045;
float _698566;
_698566 = _698563 + _698565;
float _697369;
_697369 = _697366 + _697368;
int _692818;
_692818 = 14 * _692817;
int _691195;
_691195 = 14 * _691194;
float _698455;
_698455 = _698452 + _698454;
float _696953;
_696953 = _696950 + _696952;
int _695563;
_695563 = 14 * _695562;
float _695936;
_695936 = _695933 + _695935;
float _695829;
_695829 = _695825 + _695828;
int _689400;
_689400 = 14 * _689399;
float _696380;
_696380 = _696377 + _696379;
float _696115;
_696115 = _696112 + _696114;
int _690069;
_690069 = 14 * _690068;
int _690104;
_690104 = 14 * _690103;
float _696624;
_696624 = _696621 + _696623;
int _693310;
_693310 = 14 * _693309;
int _689048;
_689048 = 14 * _689047;
int _689013;
_689013 = 14 * _689012;
float _696791;
_696791 = _696788 + _696790;
float _695883;
_695883 = _695880 + _695882;
float _696074;
_696074 = _696071 + _696073;
float _696939;
_696939 = _696936 + _696938;
int _690879;
_690879 = 14 * _690878;
int _693451;
_693451 = 14 * _693450;
float _698223;
_698223 = _698220 + _698222;
float _698031;
_698031 = _698028 + _698030;
int _693396;
_693396 = _693381 + zi_688765;
float _698497;
_698497 = _698494 + _698496;
float _696126;
_696126 = _696123 + _696125;
float _697646;
_697646 = _697643 + _697645;
float _697435;
_697435 = _697432 + _697434;
float _696348;
_696348 = _696345 + _696347;
int _692903;
_692903 = _692888 + zi_688765;
float _697343;
_697343 = _697340 + _697342;
int _691070;
_691070 = _691055 + zi_688765;
float _696469;
_696469 = _696466 + _696468;
float _697036;
_697036 = _697033 + _697035;
float _697946;
_697946 = _697943 + _697945;
float _697740;
_697740 = _697737 + _697739;
float _697660;
_697660 = _697657 + _697659;
float _697683;
_697683 = _697680 + _697682;
int _690562;
_690562 = 14 * _690561;
int _690632;
_690632 = 14 * _690631;
int _690597;
_690597 = 14 * _690596;
int _690667;
_690667 = 14 * _690666;
float _697469;
_697469 = _697466 + _697468;
float _696201;
_696201 = _696198 + _696200;
int _691442;
_691442 = 14 * _691441;
float _696820;
_696820 = _696817 + _696819;
int _694452;
_694452 = _694437 + zi_688765;
float _696964;
_696964 = _696961 + _696963;
float _697864;
_697864 = _697861 + _697863;
float _697767;
_697767 = _697764 + _697766;
float _697590;
_697590 = _697587 + _697589;
float _697626;
_697626 = _697623 + _697625;
int _692973;
_692973 = _692958 + zi_688765;
int _690843;
_690843 = 14 * _690842;
int _690738;
_690738 = 14 * _690737;
int _690773;
_690773 = 14 * _690772;
float _696060;
_696060 = _696057 + _696059;
float _696996;
_696996 = _696993 + _696995;
int _693220;
_693220 = _693205 + zi_688765;
float _696872;
_696872 = _696869 + _696871;
float _696431;
_696431 = _696428 + _696430;
int _690999;
_690999 = _690984 + zi_688765;
float _696118;
_696118 = _696115 + _696117;
float _697008;
_697008 = _697005 + _697007;
float _697604;
_697604 = _697601 + _697603;
float _696734;
_696734 = _696731 + _696733;
int _694366;
_694366 = 14 * _694365;
int _694331;
_694331 = 14 * _694330;
float _697836;
_697836 = _697833 + _697835;
int _690823;
_690823 = _690808 + zi_688765;
float _697022;
_697022 = _697019 + _697021;
float _697331;
_697331 = _697328 + _697330;
float _698458;
_698458 = _698455 + _698457;
float _697244;
_697244 = _697241 + _697243;
float _696434;
_696434 = _696431 + _696433;
float _696215;
_696215 = _696212 + _696214;
float _696956;
_696956 = _696953 + _696955;
float _696517;
_696517 = _696514 + _696516;
int _688837;
_688837 = 14 * _688836;
int _688763;
_688763 = 14 * _688762;
int _688872;
_688872 = 14 * _688871;
int _688802;
_688802 = 14 * _688801;
float _697119;
_697119 = _697116 + _697118;
float _697999;
_697999 = _697996 + _697998;
int _693134;
_693134 = 14 * _693133;
float _695886;
_695886 = _695883 + _695885;
float _696656;
_696656 = _696653 + _696655;
float _698359;
_698359 = _698356 + _698358;
float _697839;
_697839 = _697836 + _697838;
int _694120;
_694120 = 14 * _694119;
int _694050;
_694050 = 14 * _694049;
float _696803;
_696803 = _696800 + _696802;
float _697576;
_697576 = _697573 + _697575;
int _690210;
_690210 = 14 * _690209;
float _697878;
_697878 = _697875 + _697877;
float _697094;
_697094 = _697091 + _697093;
int _691175;
_691175 = _691160 + zi_688765;
int _691034;
_691034 = _691019 + zi_688765;
float _697698;
_697698 = _697695 + _697697;
int _690260;
_690260 = _690245 + zi_688765;
int _691899;
_691899 = 14 * _691898;
int _691864;
_691864 = 14 * _691863;
int _691829;
_691829 = 14 * _691828;
float _697723;
_697723 = _697720 + _697722;
float _698238;
_698238 = _698235 + _698237;
int _694628;
_694628 = _694613 + zi_688765;
float _697895;
_697895 = _697892 + _697894;
float _697236;
_697236 = _697233 + _697235;
float _697935;
_697935 = _697932 + _697934;
float _695988;
_695988 = _695985 + _695987;
float _697383;
_697383 = _697380 + _697382;
float _697881;
_697881 = _697878 + _697880;
float _698013;
_698013 = _698010 + _698012;
float _697424;
_697424 = _697421 + _697423;
float _697824;
_697824 = _697821 + _697823;
float _697108;
_697108 = _697105 + _697107;
float _695852;
_695852 = _695849 + _695851;
float _697579;
_697579 = _697576 + _697578;
float _698305;
_698305 = _698302 + _698304;
int _693537;
_693537 = _693522 + zi_688765;
float _695816;
_695816 = 1.000000e+00f - yf_695815;
float _697143;
_697143 = _697140 + _697142;
float _697131;
_697131 = _697128 + _697130;
float _697709;
_697709 = _697706 + _697708;
float _698123;
_698123 = _698120 + _698122;
float _697521;
_697521 = _697518 + _697520;
float _697938;
_697938 = _697935 + _697937;
float _695841;
_695841 = _695838 + _695840;
float _696389;
_696389 = _696386 + _696388;
float _697827;
_697827 = _697824 + _697826;
float _698440;
_698440 = _698437 + _698439;
int _688922;
_688922 = _688907 + zi_688765;
int _694754;
_694754 = 14 * _694753;
int _694894;
_694894 = 14 * _694893;
int _694100;
_694100 = _694085 + zi_688765;
float _696037;
_696037 = _696034 + _696036;
float _695939;
_695939 = _695936 + _695938;
float _696704;
_696704 = _696701 + _696703;
float _697277;
_697277 = _697274 + _697276;
int _692020;
_692020 = _692005 + zi_688765;
int _693079;
_693079 = _693064 + zi_688765;
int _695352;
_695352 = 14 * _695351;
int _695282;
_695282 = 14 * _695281;
float _696543;
_696543 = _696540 + _696542;
int _692868;
_692868 = _692853 + zi_688765;
int _694241;
_694241 = _694226 + zi_688765;
int _691457;
_691457 = _691442 + zi_688765;
int _692938;
_692938 = _692923 + zi_688765;
int _690894;
_690894 = _690879 + zi_688765;
int _691210;
_691210 = _691195 + zi_688765;
int _688887;
_688887 = _688872 + zi_688765;
int _690014;
_690014 = _689999 + zi_688765;
int _693044;
_693044 = _693029 + zi_688765;
int _692055;
_692055 = _692040 + zi_688765;
int _694909;
_694909 = _694894 + zi_688765;
int _693114;
_693114 = _693099 + zi_688765;
int _695332;
_695332 = _695317 + zi_688765;
int _691985;
_691985 = _691970 + zi_688765;
int _688852;
_688852 = _688837 + zi_688765;
int _690366;
_690366 = _690351 + zi_688765;
int _694663;
_694663 = _694648 + zi_688765;
int _693501;
_693501 = _693486 + zi_688765;
int _693149;
_693149 = _693134 + zi_688765;
int _695191;
_695191 = _695176 + zi_688765;
int _690753;
_690753 = _690738 + zi_688765;
int _688958;
_688958 = _688943 + zi_688765;
int _688782;
_688782 = _688763 + zi_688765;
int _690858;
_690858 = _690843 + zi_688765;
int _689591;
_689591 = _689576 + zi_688765;
int _693677;
_693677 = _693662 + zi_688765;
int _693607;
_693607 = _693592 + zi_688765;
int _692481;
_692481 = _692466 + zi_688765;
int _693290;
_693290 = _693275 + zi_688765;
int _692833;
_692833 = _692818 + zi_688765;
int _692551;
_692551 = _692536 + zi_688765;
int _694346;
_694346 = _694331 + zi_688765;
int _693572;
_693572 = _693557 + zi_688765;
int _690542;
_690542 = _690527 + zi_688765;
int _691281;
_691281 = _691266 + zi_688765;
int _694980;
_694980 = _694965 + zi_688765;
int _694381;
_694381 = _694366 + zi_688765;
int _695649;
_695649 = _695634 + zi_688765;
int _694593;
_694593 = _694578 + zi_688765;
int _691844;
_691844 = _691829 + zi_688765;
int _691879;
_691879 = _691864 + zi_688765;
int _690682;
_690682 = _690667 + zi_688765;
int _692288;
_692288 = 1 + zi_688765;
int _694417;
_694417 = _694402 + zi_688765;
int _690330;
_690330 = _690315 + zi_688765;
int _690788;
_690788 = _690773 + zi_688765;
int _692196;
_692196 = _692181 + zi_688765;
int _689732;
_689732 = _689717 + zi_688765;
int _690929;
_690929 = _690914 + zi_688765;
int _690154;
_690154 = _690139 + zi_688765;
int _691703;
_691703 = _691688 + zi_688765;
int _691914;
_691914 = _691899 + zi_688765;
int _695437;
_695437 = _695422 + zi_688765;
int _690964;
_690964 = _690949 + zi_688765;
int _689380;
_689380 = _689365 + zi_688765;
int _692727;
_692727 = _692712 + zi_688765;
int _690084;
_690084 = _690069 + zi_688765;
int _690225;
_690225 = _690210 + zi_688765;
int _690612;
_690612 = _690597 + zi_688765;
int _689486;
_689486 = _689471 + zi_688765;
int _691633;
_691633 = _691618 + zi_688765;
int _692090;
_692090 = _692075 + zi_688765;
int _690647;
_690647 = _690632 + zi_688765;
int _693431;
_693431 = _693416 + zi_688765;
int _695156;
_695156 = _695141 + zi_688765;
int _694945;
_694945 = _694930 + zi_688765;
int _694135;
_694135 = _694120 + zi_688765;
int _689415;
_689415 = _689400 + zi_688765;
int _689626;
_689626 = _689611 + zi_688765;
int _691774;
_691774 = _691759 + zi_688765;
int _695367;
_695367 = _695352 + zi_688765;
int _694487;
_694487 = _694472 + zi_688765;
int _689028;
_689028 = _689013 + zi_688765;
int _693466;
_693466 = _693451 + zi_688765;
int _695543;
_695543 = _695528 + zi_688765;
int _694065;
_694065 = _694050 + zi_688765;
int _689310;
_689310 = _689295 + zi_688765;
int _693185;
_693185 = _693170 + zi_688765;
int _690295;
_690295 = _690280 + zi_688765;
int _689450;
_689450 = _689435 + zi_688765;
int _694839;
_694839 = _694824 + zi_688765;
int _691527;
_691527 = _691512 + zi_688765;
int _689063;
_689063 = _689048 + zi_688765;
int _691422;
_691422 = _691407 + zi_688765;
int _694874;
_694874 = _694859 + zi_688765;
int _693642;
_693642 = _693627 + zi_688765;
int _690049;
_690049 = _690034 + zi_688765;
int _694170;
_694170 = _694155 + zi_688765;
float _698580;
_698580 = (float)zi_688765;
int _691386;
_691386 = _691371 + zi_688765;
int _689521;
_689521 = _689506 + zi_688765;
int _691809;
_691809 = _691794 + zi_688765;
int _695402;
_695402 = _695387 + zi_688765;
int _688993;
_688993 = _688978 + zi_688765;
int _691950;
_691950 = _691935 + zi_688765;
int _688766;
_688766 = zi_688765 - 2;
int _691562;
_691562 = _691547 + zi_688765;
int _694276;
_694276 = _694261 + zi_688765;
int _688774;
_688774 = zi_688765 - 1;
int _694769;
_694769 = _694754 + zi_688765;
int _694804;
_694804 = _694789 + zi_688765;
int _689556;
_689556 = _689541 + zi_688765;
int _693009;
_693009 = _692994 + zi_688765;
int _688817;
_688817 = _688802 + zi_688765;
int _694698;
_694698 = _694683 + zi_688765;
int _693325;
_693325 = _693310 + zi_688765;
int _695297;
_695297 = _695282 + zi_688765;
int _690119;
_690119 = _690104 + zi_688765;
int _689697;
_689697 = _689682 + zi_688765;
int _690577;
_690577 = _690562 + zi_688765;
int _690401;
_690401 = _690386 + zi_688765;
int _695578;
_695578 = _695563 + zi_688765;
int _690190;
_690190 = _690175 + zi_688765;
float _698509;
_698509 = _698506 + _698508;
int _691583;
_691583 = 14 * _691582;
int _691653;
_691653 = 14 * _691652;
float _695855;
_695855 = _695852 + _695854;
float _696610;
_696610 = _696607 + _696609;
int _691936;
_691936 = _691935 + _688766;
int _691943;
_691943 = _691935 + _688774;
float _697358;
_697358 = _697355 + _697357;
float _697160;
_697160 = _697157 + _697159;
float _695858;
_695858 = _695855 + _695857;
float _698195;
_698195 = _698192 + _698194;
int _695739;
_695739 = 14 * _695738;
int _695704;
_695704 = 14 * _695703;
int _695669;
_695669 = 14 * _695668;
int _695774;
_695774 = 14 * _695773;
float _696529;
_696529 = _696526 + _696528;
float _696414;
_696414 = _696411 + _696413;
int _690387;
_690387 = _690386 + _688766;
int _690394;
_690394 = _690386 + _688774;
float _695820;
_695820 = 1.000000e+00f - xf_695819;
int _693909;
_693909 = 14 * _693908;
int _693874;
_693874 = 14 * _693873;
int _693944;
_693944 = 14 * _693943;
int _694014;
_694014 = 14 * _694013;
int _693979;
_693979 = 14 * _693978;
int _689893;
_689893 = 14 * _689892;
int _689858;
_689858 = 14 * _689857;
int _689823;
_689823 = 14 * _689822;
int _689963;
_689963 = 14 * _689962;
int _689928;
_689928 = 14 * _689927;
float _698112;
_698112 = _698109 + _698111;
float _697074;
_697074 = _697071 + _697073;
int _690140;
_690140 = _690139 + _688766;
int _690147;
_690147 = _690139 + _688774;
float _698226;
_698226 = _698223 + _698225;
float _696762;
_696762 = _696759 + _696761;
int _690176;
_690176 = _690175 + _688766;
int _690183;
_690183 = _690175 + _688774;
float _696049;
_696049 = _696046 + _696048;
float _696857;
_696857 = _696854 + _696856;
float _695899;
_695899 = _695896 + _695898;
float _696005;
_696005 = _696002 + _696004;
float _698317;
_698317 = _698314 + _698316;
float _696317;
_696317 = _696314 + _696316;
int _691795;
_691795 = _691794 + _688766;
int _691802;
_691802 = _691794 + _688774;
float _696967;
_696967 = _696964 + _696966;
float _696725;
_696725 = _696722 + _696724;
float _696596;
_696596 = _696593 + _696595;
float _696455;
_696455 = _696452 + _696454;
int _689683;
_689683 = _689682 + _688766;
int _689690;
_689690 = _689682 + _688774;
int _692782;
_692782 = 14 * _692781;
int _692747;
_692747 = 14 * _692746;
int _692642;
_692642 = 14 * _692641;
int _692677;
_692677 = 14 * _692676;
float _697412;
_697412 = _697409 + _697411;
int _695106;
_695106 = 14 * _695105;
int _695211;
_695211 = 14 * _695210;
float _697795;
_697795 = _697792 + _697794;
float _696483;
_696483 = _696480 + _696482;
int _691231;
_691231 = 14 * _691230;
int _691336;
_691336 = 14 * _691335;
int _691301;
_691301 = 14 * _691300;
float _698100;
_698100 = _698097 + _698099;
int _692501;
_692501 = 14 * _692500;
int _692571;
_692571 = 14 * _692570;
int _692606;
_692606 = 14 * _692605;
float _698278;
_698278 = _698275 + _698277;
int _693268;
_693268 = 5 + _693255;
int _693262;
_693262 = 4 + _693255;
int _693256;
_693256 = 3 + _693255;
float _697507;
_697507 = _697504 + _697506;
float _696930;
_696930 = _696927 + _696929;
float _695911;
_695911 = _695908 + _695910;
float _698386;
_698386 = _698383 + _698385;
int _689296;
_689296 = _689295 + _688766;
int _689303;
_689303 = _689295 + _688774;
float _698159;
_698159 = _698157 + _698158;
int _689366;
_689366 = _689365 + _688766;
int _689373;
_689373 = _689365 + _688774;
float _698016;
_698016 = _698013 + _698015;
float _696088;
_696088 = _696085 + _696087;
float _697778;
_697778 = _697775 + _697777;
float _697617;
_697617 = _697614 + _697616;
int _690950;
_690950 = _690949 + _688766;
int _690957;
_690957 = _690949 + _688774;
int _691118;
_691118 = 4 + _691105;
int _691112;
_691112 = 3 + _691105;
int _691106;
_691106 = 2 + _691105;
float _696613;
_696613 = _696610 + _696612;
int _694746;
_694746 = 5 + _694733;
int _694740;
_694740 = 4 + _694733;
int _694734;
_694734 = 3 + _694733;
float _697219;
_697219 = _697216 + _697218;
int _690281;
_690281 = _690280 + _688766;
int _690288;
_690288 = _690280 + _688774;
float _696008;
_696008 = _696005 + _696007;
float _697674;
_697674 = _697671 + _697673;
float _696571;
_696571 = _696568 + _696570;
int _691513;
_691513 = _691512 + _688766;
int _691520;
_691520 = _691512 + _688774;
int _688944;
_688944 = _688943 + _688766;
int _688951;
_688951 = _688943 + _688774;
float _698115;
_698115 = _698112 + _698114;
int _695521;
_695521 = 5 + _695508;
int _695515;
_695515 = 4 + _695508;
int _695509;
_695509 = 3 + _695508;
int _692041;
_692041 = _692040 + _688766;
int _692048;
_692048 = _692040 + _688774;
float _696557;
_696557 = _696554 + _696556;
float _696753;
_696753 = _696751 + _696752;
float _696779;
_696779 = _696776 + _696778;
float _696311;
_696311 = _696308 + _696310;
int _690484;
_690484 = 4 + _690471;
int _690478;
_690478 = 3 + _690471;
int _690472;
_690472 = 2 + _690471;
float _697210;
_697210 = _697207 + _697209;
int _690316;
_690316 = _690315 + _688766;
int _690323;
_690323 = _690315 + _688774;
int _694324;
_694324 = 5 + _694311;
int _694318;
_694318 = 4 + _694311;
int _694312;
_694312 = 3 + _694311;
float _696223;
_696223 = _696220 + _696222;
int _691267;
_691267 = _691266 + _688766;
int _691274;
_691274 = _691266 + _688774;
float _696339;
_696339 = _696337 + _696338;
float _695968;
_695968 = _695965 + _695967;
float _696503;
_696503 = _696500 + _696502;
float _698043;
_698043 = _698040 + _698042;
float _696016;
_696016 = _696013 + _696015;
int _689436;
_689436 = _689435 + _688766;
int _689443;
_689443 = _689435 + _688774;
float _697449;
_697449 = _697446 + _697448;
int _691548;
_691548 = _691547 + _688766;
int _691555;
_691555 = _691547 + _688774;
float _696140;
_696140 = _696137 + _696139;
int _692076;
_692076 = _692075 + _688766;
int _692083;
_692083 = _692075 + _688774;
float _697524;
_697524 = _697521 + _697523;
float _696181;
_696181 = _696178 + _696180;
int _695626;
_695626 = 5 + _695613;
int _695620;
_695620 = 4 + _695613;
int _695614;
_695614 = 3 + _695613;
int _691408;
_691408 = _691407 + _688766;
int _691415;
_691415 = _691407 + _688774;
float _695869;
_695869 = _695866 + _695868;
float _698137;
_698137 = _698134 + _698136;
float _697062;
_697062 = _697059 + _697061;
int _693698;
_693698 = 14 * _693697;
int _693768;
_693768 = 14 * _693767;
int _693803;
_693803 = 14 * _693802;
int _693733;
_693733 = 14 * _693732;
int _693838;
_693838 = 14 * _693837;
float _695974;
_695974 = _695971 + _695973;
int _695000;
_695000 = 14 * _694999;
int _695070;
_695070 = 14 * _695069;
int _695035;
_695035 = 14 * _695034;
int _688979;
_688979 = _688978 + _688766;
int _688986;
_688986 = _688978 + _688774;
float _697053;
_697053 = _697050 + _697052;
float _698428;
_698428 = _698425 + _698427;
float _696351;
_696351 = _696348 + _696350;
float _695925;
_695925 = _695922 + _695924;
float _696875;
_696875 = _696872 + _696874;
float _696172;
_696172 = _696169 + _696171;
int _691689;
_691689 = _691688 + _688766;
int _691696;
_691696 = _691688 + _688774;
float _696129;
_696129 = _696126 + _696128;
float _696486;
_696486 = _696483 + _696485;
int _689577;
_689577 = _689576 + _688766;
int _689584;
_689584 = _689576 + _688774;
int _695274;
_695274 = 5 + _695261;
int _695268;
_695268 = 4 + _695261;
int _695262;
_695262 = 3 + _695261;
int _689154;
_689154 = 14 * _689153;
int _689259;
_689259 = 14 * _689258;
int _689189;
_689189 = 14 * _689188;
int _689224;
_689224 = 14 * _689223;
int _689119;
_689119 = 14 * _689118;
float _697185;
_697185 = _697182 + _697184;
float _698269;
_698269 = _698267 + _698268;
int _689111;
_689111 = 4 + _689098;
int _689105;
_689105 = 3 + _689098;
int _689099;
_689099 = 2 + _689098;
int _690731;
_690731 = 4 + _690718;
int _690725;
_690725 = 3 + _690718;
int _690719;
_690719 = 2 + _690718;
float _698524;
_698524 = _698521 + _698523;
float _697402;
_697402 = _697400 + _697401;
float _696682;
_696682 = _696679 + _696681;
float _698549;
_698549 = _698546 + _698548;
float _697427;
_697427 = _697424 + _697426;
float _697752;
_697752 = _697749 + _697751;
float _698541;
_698541 = _698538 + _698540;
float _697174;
_697174 = _697171 + _697173;
float _698397;
_698397 = _698394 + _698396;
float _695947;
_695947 = _695944 + _695946;
int _691751;
_691751 = 4 + _691738;
int _691745;
_691745 = 3 + _691738;
int _691739;
_691739 = 2 + _691738;
int _692430;
_692430 = 14 * _692429;
int _692395;
_692395 = 14 * _692394;
int _692287;
_692287 = 14 * _692286;
int _692360;
_692360 = 14 * _692359;
int _692325;
_692325 = 14 * _692324;
int _689507;
_689507 = _689506 + _688766;
int _689514;
_689514 = _689506 + _688774;
float _697297;
_697297 = _697294 + _697296;
float _698209;
_698209 = _698206 + _698208;
float _697532;
_697532 = _697529 + _697531;
float _695872;
_695872 = _695869 + _695871;
int _689780;
_689780 = 4 + _689767;
int _689774;
_689774 = 3 + _689767;
int _689768;
_689768 = 2 + _689767;
float _698082;
_698082 = _698079 + _698081;
float _697985;
_697985 = _697982 + _697984;
float _697493;
_697493 = _697490 + _697492;
float _698255;
_698255 = _698253 + _698254;
float _697286;
_697286 = _697283 + _697285;
int _691153;
_691153 = 4 + _691140;
int _691147;
_691147 = 3 + _691140;
int _691141;
_691141 = 2 + _691140;
float _698466;
_698466 = _698463 + _698465;
int _691372;
_691372 = _691371 + _688766;
int _691379;
_691379 = _691371 + _688774;
float _696850;
_696850 = _696848 + _696849;
int _691760;
_691760 = _691759 + _688766;
int _691767;
_691767 = _691759 + _688774;
float _696236;
_696236 = _696233 + _696235;
float _696276;
_696276 = _696273 + _696275;
int _689675;
_689675 = 4 + _689662;
int _689669;
_689669 = 3 + _689662;
int _689663;
_689663 = 2 + _689662;
float _696362;
_696362 = _696359 + _696361;
int _693374;
_693374 = 5 + _693361;
int _693368;
_693368 = 4 + _693361;
int _693362;
_693362 = 3 + _693361;
float _697510;
_697510 = _697507 + _697509;
float _696446;
_696446 = _696443 + _696445;
float _697258;
_697258 = _697255 + _697257;
float _697924;
_697924 = _697921 + _697923;
float _697222;
_697222 = _697219 + _697221;
int _692216;
_692216 = 14 * _692215;
int _692251;
_692251 = 14 * _692250;
int _692146;
_692146 = 14 * _692145;
int _692111;
_692111 = 14 * _692110;
float _696999;
_696999 = _696996 + _696998;
float _696296;
_696296 = _696293 + _696295;
float _698345;
_698345 = _698342 + _698344;
int _691971;
_691971 = _691970 + _688766;
int _691978;
_691978 = _691970 + _688774;
float _696132;
_696132 = _696129 + _696131;
float _697311;
_697311 = _697308 + _697310;
int _690519;
_690519 = 4 + _690506;
int _690513;
_690513 = 3 + _690506;
int _690507;
_690507 = 2 + _690506;
float _698060;
_698060 = _698057 + _698059;
int _694570;
_694570 = 5 + _694557;
int _694564;
_694564 = 4 + _694557;
int _694558;
_694558 = 3 + _694557;
float _698411;
_698411 = _698408 + _698410;
float _696254;
_696254 = _696251 + _696253;
int _689815;
_689815 = 4 + _689802;
int _689809;
_689809 = 3 + _689802;
int _689803;
_689803 = 2 + _689802;
int _694218;
_694218 = 5 + _694205;
int _694212;
_694212 = 4 + _694205;
int _694206;
_694206 = 3 + _694205;
float _697077;
_697077 = _697074 + _697076;
float _697812;
_697812 = _697809 + _697811;
float _697478;
_697478 = _697475 + _697477;
float _698569;
_698569 = _698566 + _698568;
float _696546;
_696546 = _696543 + _696545;
float _698336;
_698336 = _698334 + _698335;
float _696891;
_696891 = _696889 + _696890;
int _689542;
_689542 = _689541 + _688766;
int _689549;
_689549 = _689541 + _688774;
float _697547;
_697547 = _697544 + _697546;
float _696400;
_696400 = _696397 + _696399;
float _696828;
_696828 = _696825 + _696827;
float _696154;
_696154 = _696151 + _696153;
float _696581;
_696581 = _696578 + _696580;
int _692182;
_692182 = _692181 + _688766;
int _692189;
_692189 = _692181 + _688774;
float _698181;
_698181 = _698178 + _698180;
float _697971;
_697971 = _697968 + _697970;
int _690035;
_690035 = _690034 + _688766;
int _690042;
_690042 = _690034 + _688774;
float _698174;
_698174 = _698172 + _698173;
float _697959;
_697959 = _697956 + _697958;
float _696103;
_696103 = _696100 + _696102;
float _698002;
_698002 = _697999 + _698001;
float _696919;
_696919 = _696917 + _696918;
float _696665;
_696665 = _696662 + _696664;
int _689718;
_689718 = _689717 + _688766;
int _689725;
_689725 = _689717 + _688774;
float _698241;
_698241 = _698238 + _698240;
int _690915;
_690915 = _690914 + _688766;
int _690922;
_690922 = _690914 + _688774;
float _697910;
_697910 = _697907 + _697909;
int _691505;
_691505 = 4 + _691492;
int _691499;
_691499 = 3 + _691492;
int _691493;
_691493 = 2 + _691492;
float _697261;
_697261 = _697258 + _697260;
float _696978;
_696978 = _696975 + _696977;
int _694535;
_694535 = 5 + _694522;
int _694529;
_694529 = 4 + _694522;
int _694523;
_694523 = 3 + _694522;
float _698480;
_698480 = _698477 + _698479;
float _697847;
_697847 = _697844 + _697846;
float _697134;
_697134 = _697131 + _697133;
float _696638;
_696638 = _696635 + _696637;
float _696693;
_696693 = _696690 + _696692;
int _689472;
_689472 = _689471 + _688766;
int _689479;
_689479 = _689471 + _688774;
float _696574;
_696574 = _696571 + _696573;
float _698289;
_698289 = _698286 + _698288;
int _689358;
_689358 = 4 + _689345;
int _689352;
_689352 = 3 + _689345;
int _689346;
_689346 = 2 + _689345;
float _698068;
_698068 = _698065 + _698067;
float _697011;
_697011 = _697008 + _697010;
int _690449;
_690449 = 4 + _690436;
int _690443;
_690443 = 3 + _690436;
int _690437;
_690437 = 2 + _690436;
float _696897;
_696897 = _696894 + _696896;
int _689612;
_689612 = _689611 + _688766;
int _689619;
_689619 = _689611 + _688774;
float _698374;
_698374 = _698371 + _698373;
int _691619;
_691619 = _691618 + _688766;
int _691626;
_691626 = _691618 + _688774;
float _697962;
_697962 = _697959 + _697961;
float _696942;
_696942 = _696939 + _696941;
int _690528;
_690528 = _690527 + _688766;
int _690535;
_690535 = _690527 + _688774;
int _695486;
_695486 = 5 + _695473;
int _695480;
_695480 = 4 + _695473;
int _695474;
_695474 = 3 + _695473;
float _696268;
_696268 = _696265 + _696267;
int _690352;
_690352 = _690351 + _688766;
int _690359;
_690359 = _690351 + _688774;
float _697567;
_697567 = _697565 + _697566;
float _697372;
_697372 = _697369 + _697371;
int _691196;
_691196 = _691195 + _688766;
int _691203;
_691203 = _691195 + _688774;
float _695832;
_695832 = _695829 + _695831;
int _689401;
_689401 = _689400 + _688766;
int _689408;
_689408 = _689400 + _688774;
float _696382;
_696382 = _696380 + _696381;
int _690070;
_690070 = _690069 + _688766;
int _690077;
_690077 = _690069 + _688774;
int _690105;
_690105 = _690104 + _688766;
int _690112;
_690112 = _690104 + _688774;
float _696627;
_696627 = _696624 + _696626;
int _689049;
_689049 = _689048 + _688766;
int _689056;
_689056 = _689048 + _688774;
int _689014;
_689014 = _689013 + _688766;
int _689021;
_689021 = _689013 + _688774;
float _696794;
_696794 = _696791 + _696793;
float _696077;
_696077 = _696074 + _696076;
int _690880;
_690880 = _690879 + _688766;
int _690887;
_690887 = _690879 + _688774;
float _698034;
_698034 = _698031 + _698033;
int _693409;
_693409 = 5 + _693396;
int _693403;
_693403 = 4 + _693396;
int _693397;
_693397 = 3 + _693396;
float _698500;
_698500 = _698497 + _698499;
float _697648;
_697648 = _697646 + _697647;
float _697438;
_697438 = _697435 + _697437;
int _692916;
_692916 = 5 + _692903;
int _692910;
_692910 = 4 + _692903;
int _692904;
_692904 = 3 + _692903;
float _697346;
_697346 = _697343 + _697345;
int _691083;
_691083 = 4 + _691070;
int _691077;
_691077 = 3 + _691070;
int _691071;
_691071 = 2 + _691070;
float _696472;
_696472 = _696469 + _696471;
float _697039;
_697039 = _697036 + _697038;
float _697949;
_697949 = _697946 + _697948;
float _697743;
_697743 = _697740 + _697742;
float _697662;
_697662 = _697660 + _697661;
float _697686;
_697686 = _697683 + _697685;
int _690563;
_690563 = _690562 + _688766;
int _690570;
_690570 = _690562 + _688774;
int _690633;
_690633 = _690632 + _688766;
int _690640;
_690640 = _690632 + _688774;
int _690598;
_690598 = _690597 + _688766;
int _690605;
_690605 = _690597 + _688774;
int _690668;
_690668 = _690667 + _688766;
int _690675;
_690675 = _690667 + _688774;
float _697471;
_697471 = _697469 + _697470;
float _696203;
_696203 = _696201 + _696202;
int _691443;
_691443 = _691442 + _688766;
int _691450;
_691450 = _691442 + _688774;
float _696822;
_696822 = _696820 + _696821;
int _694465;
_694465 = 5 + _694452;
int _694459;
_694459 = 4 + _694452;
int _694453;
_694453 = 3 + _694452;
float _697867;
_697867 = _697864 + _697866;
float _697770;
_697770 = _697767 + _697769;
float _697593;
_697593 = _697590 + _697592;
float _697629;
_697629 = _697626 + _697628;
int _692986;
_692986 = 5 + _692973;
int _692980;
_692980 = 4 + _692973;
int _692974;
_692974 = 3 + _692973;
int _690844;
_690844 = _690843 + _688766;
int _690851;
_690851 = _690843 + _688774;
int _690739;
_690739 = _690738 + _688766;
int _690746;
_690746 = _690738 + _688774;
int _690774;
_690774 = _690773 + _688766;
int _690781;
_690781 = _690773 + _688774;
float _696063;
_696063 = _696060 + _696062;
int _693233;
_693233 = 5 + _693220;
int _693227;
_693227 = 4 + _693220;
int _693221;
_693221 = 3 + _693220;
int _691012;
_691012 = 4 + _690999;
int _691006;
_691006 = 3 + _690999;
int _691000;
_691000 = 2 + _690999;
float _696120;
_696120 = _696118 + _696119;
float _697607;
_697607 = _697604 + _697606;
float _696737;
_696737 = _696734 + _696736;
int _690836;
_690836 = 4 + _690823;
int _690830;
_690830 = 3 + _690823;
int _690824;
_690824 = 2 + _690823;
float _697025;
_697025 = _697022 + _697024;
float _697333;
_697333 = _697331 + _697332;
float _698460;
_698460 = _698458 + _698459;
float _697247;
_697247 = _697244 + _697246;
float _696436;
_696436 = _696434 + _696435;
float _696217;
_696217 = _696215 + _696216;
float _696958;
_696958 = _696956 + _696957;
float _696520;
_696520 = _696517 + _696519;
int _688838;
_688838 = _688837 + _688766;
int _688845;
_688845 = _688837 + _688774;
int _688767;
_688767 = _688763 + _688766;
int _688775;
_688775 = _688763 + _688774;
int _688873;
_688873 = _688872 + _688766;
int _688880;
_688880 = _688872 + _688774;
int _688803;
_688803 = _688802 + _688766;
int _688810;
_688810 = _688802 + _688774;
float _697122;
_697122 = _697119 + _697121;
float _695888;
_695888 = _695886 + _695887;
float _696658;
_696658 = _696656 + _696657;
float _698362;
_698362 = _698359 + _698361;
float _697841;
_697841 = _697839 + _697840;
float _696806;
_696806 = _696803 + _696805;
int _690211;
_690211 = _690210 + _688766;
int _690218;
_690218 = _690210 + _688774;
float _697096;
_697096 = _697094 + _697095;
int _691188;
_691188 = 4 + _691175;
int _691182;
_691182 = 3 + _691175;
int _691176;
_691176 = 2 + _691175;
int _691047;
_691047 = 4 + _691034;
int _691041;
_691041 = 3 + _691034;
int _691035;
_691035 = 2 + _691034;
float _697701;
_697701 = _697698 + _697700;
int _690273;
_690273 = 4 + _690260;
int _690267;
_690267 = 3 + _690260;
int _690261;
_690261 = 2 + _690260;
int _691900;
_691900 = _691899 + _688766;
int _691907;
_691907 = _691899 + _688774;
int _691865;
_691865 = _691864 + _688766;
int _691872;
_691872 = _691864 + _688774;
int _691830;
_691830 = _691829 + _688766;
int _691837;
_691837 = _691829 + _688774;
float _697726;
_697726 = _697723 + _697725;
int _694641;
_694641 = 5 + _694628;
int _694635;
_694635 = 4 + _694628;
int _694629;
_694629 = 3 + _694628;
float _697898;
_697898 = _697895 + _697897;
float _697238;
_697238 = _697236 + _697237;
float _695991;
_695991 = _695988 + _695990;
float _697386;
_697386 = _697383 + _697385;
float _697883;
_697883 = _697881 + _697882;
float _697110;
_697110 = _697108 + _697109;
float _697581;
_697581 = _697579 + _697580;
float _698308;
_698308 = _698305 + _698307;
int _693550;
_693550 = 5 + _693537;
int _693544;
_693544 = 4 + _693537;
int _693538;
_693538 = 3 + _693537;
float _697146;
_697146 = _697143 + _697145;
float _697712;
_697712 = _697709 + _697711;
float _698126;
_698126 = _698123 + _698125;
float _697940;
_697940 = _697938 + _697939;
float _695844;
_695844 = _695841 + _695843;
float _696392;
_696392 = _696389 + _696391;
float _697829;
_697829 = _697827 + _697828;
float _698443;
_698443 = _698440 + _698442;
int _688935;
_688935 = 4 + _688922;
int _688929;
_688929 = 3 + _688922;
int _688923;
_688923 = 2 + _688922;
int _694113;
_694113 = 5 + _694100;
int _694107;
_694107 = 4 + _694100;
int _694101;
_694101 = 3 + _694100;
float _696039;
_696039 = _696037 + _696038;
float _695941;
_695941 = _695939 + _695940;
float _696707;
_696707 = _696704 + _696706;
float _697279;
_697279 = _697277 + _697278;
int _692033;
_692033 = 4 + _692020;
int _692027;
_692027 = 3 + _692020;
int _692021;
_692021 = 2 + _692020;
int _693092;
_693092 = 5 + _693079;
int _693086;
_693086 = 4 + _693079;
int _693080;
_693080 = 3 + _693079;
int _692881;
_692881 = 5 + _692868;
int _692875;
_692875 = 4 + _692868;
int _692869;
_692869 = 3 + _692868;
int _694254;
_694254 = 5 + _694241;
int _694248;
_694248 = 4 + _694241;
int _694242;
_694242 = 3 + _694241;
int _691470;
_691470 = 4 + _691457;
int _691464;
_691464 = 3 + _691457;
int _691458;
_691458 = 2 + _691457;
int _692951;
_692951 = 5 + _692938;
int _692945;
_692945 = 4 + _692938;
int _692939;
_692939 = 3 + _692938;
int _690907;
_690907 = 4 + _690894;
int _690901;
_690901 = 3 + _690894;
int _690895;
_690895 = 2 + _690894;
int _691223;
_691223 = 4 + _691210;
int _691217;
_691217 = 3 + _691210;
int _691211;
_691211 = 2 + _691210;
int _688900;
_688900 = 4 + _688887;
int _688894;
_688894 = 3 + _688887;
int _688888;
_688888 = 2 + _688887;
int _690027;
_690027 = 4 + _690014;
int _690021;
_690021 = 3 + _690014;
int _690015;
_690015 = 2 + _690014;
int _693057;
_693057 = 5 + _693044;
int _693051;
_693051 = 4 + _693044;
int _693045;
_693045 = 3 + _693044;
int _692068;
_692068 = 4 + _692055;
int _692062;
_692062 = 3 + _692055;
int _692056;
_692056 = 2 + _692055;
int _694922;
_694922 = 5 + _694909;
int _694916;
_694916 = 4 + _694909;
int _694910;
_694910 = 3 + _694909;
int _693127;
_693127 = 5 + _693114;
int _693121;
_693121 = 4 + _693114;
int _693115;
_693115 = 3 + _693114;
int _695345;
_695345 = 5 + _695332;
int _695339;
_695339 = 4 + _695332;
int _695333;
_695333 = 3 + _695332;
int _691998;
_691998 = 4 + _691985;
int _691992;
_691992 = 3 + _691985;
int _691986;
_691986 = 2 + _691985;
int _688865;
_688865 = 4 + _688852;
int _688859;
_688859 = 3 + _688852;
int _688853;
_688853 = 2 + _688852;
int _690379;
_690379 = 4 + _690366;
int _690373;
_690373 = 3 + _690366;
int _690367;
_690367 = 2 + _690366;
int _694676;
_694676 = 5 + _694663;
int _694670;
_694670 = 4 + _694663;
int _694664;
_694664 = 3 + _694663;
int _693514;
_693514 = 5 + _693501;
int _693508;
_693508 = 4 + _693501;
int _693502;
_693502 = 3 + _693501;
int _693162;
_693162 = 5 + _693149;
int _693156;
_693156 = 4 + _693149;
int _693150;
_693150 = 3 + _693149;
int _695204;
_695204 = 5 + _695191;
int _695198;
_695198 = 4 + _695191;
int _695192;
_695192 = 3 + _695191;
int _690766;
_690766 = 4 + _690753;
int _690760;
_690760 = 3 + _690753;
int _690754;
_690754 = 2 + _690753;
int _688971;
_688971 = 4 + _688958;
int _688965;
_688965 = 3 + _688958;
int _688959;
_688959 = 2 + _688958;
int _688795;
_688795 = 4 + _688782;
int _688789;
_688789 = 3 + _688782;
int _688783;
_688783 = 2 + _688782;
int _690871;
_690871 = 4 + _690858;
int _690865;
_690865 = 3 + _690858;
int _690859;
_690859 = 2 + _690858;
int _689604;
_689604 = 4 + _689591;
int _689598;
_689598 = 3 + _689591;
int _689592;
_689592 = 2 + _689591;
int _693690;
_693690 = 5 + _693677;
int _693684;
_693684 = 4 + _693677;
int _693678;
_693678 = 3 + _693677;
int _693620;
_693620 = 5 + _693607;
int _693614;
_693614 = 4 + _693607;
int _693608;
_693608 = 3 + _693607;
int _692494;
_692494 = 5 + _692481;
int _692488;
_692488 = 4 + _692481;
int _692482;
_692482 = 3 + _692481;
int _693303;
_693303 = 5 + _693290;
int _693297;
_693297 = 4 + _693290;
int _693291;
_693291 = 3 + _693290;
int _692846;
_692846 = 5 + _692833;
int _692840;
_692840 = 4 + _692833;
int _692834;
_692834 = 3 + _692833;
int _692564;
_692564 = 5 + _692551;
int _692558;
_692558 = 4 + _692551;
int _692552;
_692552 = 3 + _692551;
int _694359;
_694359 = 5 + _694346;
int _694353;
_694353 = 4 + _694346;
int _694347;
_694347 = 3 + _694346;
int _693585;
_693585 = 5 + _693572;
int _693579;
_693579 = 4 + _693572;
int _693573;
_693573 = 3 + _693572;
int _690555;
_690555 = 4 + _690542;
int _690549;
_690549 = 3 + _690542;
int _690543;
_690543 = 2 + _690542;
int _691294;
_691294 = 4 + _691281;
int _691288;
_691288 = 3 + _691281;
int _691282;
_691282 = 2 + _691281;
int _694993;
_694993 = 5 + _694980;
int _694987;
_694987 = 4 + _694980;
int _694981;
_694981 = 3 + _694980;
int _694394;
_694394 = 5 + _694381;
int _694388;
_694388 = 4 + _694381;
int _694382;
_694382 = 3 + _694381;
int _695662;
_695662 = 5 + _695649;
int _695656;
_695656 = 4 + _695649;
int _695650;
_695650 = 3 + _695649;
int _694606;
_694606 = 5 + _694593;
int _694600;
_694600 = 4 + _694593;
int _694594;
_694594 = 3 + _694593;
int _691857;
_691857 = 4 + _691844;
int _691851;
_691851 = 3 + _691844;
int _691845;
_691845 = 2 + _691844;
int _691892;
_691892 = 4 + _691879;
int _691886;
_691886 = 3 + _691879;
int _691880;
_691880 = 2 + _691879;
int _690695;
_690695 = 4 + _690682;
int _690689;
_690689 = 3 + _690682;
int _690683;
_690683 = 2 + _690682;
int _692297;
_692297 = _692288 - 1;
int _692289;
_692289 = _692288 - 2;
int _694430;
_694430 = 5 + _694417;
int _694424;
_694424 = 4 + _694417;
int _694418;
_694418 = 3 + _694417;
int _690343;
_690343 = 4 + _690330;
int _690337;
_690337 = 3 + _690330;
int _690331;
_690331 = 2 + _690330;
int _690801;
_690801 = 4 + _690788;
int _690795;
_690795 = 3 + _690788;
int _690789;
_690789 = 2 + _690788;
int _692209;
_692209 = 4 + _692196;
int _692203;
_692203 = 3 + _692196;
int _692197;
_692197 = 2 + _692196;
int _689745;
_689745 = 4 + _689732;
int _689739;
_689739 = 3 + _689732;
int _689733;
_689733 = 2 + _689732;
int _690942;
_690942 = 4 + _690929;
int _690936;
_690936 = 3 + _690929;
int _690930;
_690930 = 2 + _690929;
int _690167;
_690167 = 4 + _690154;
int _690161;
_690161 = 3 + _690154;
int _690155;
_690155 = 2 + _690154;
int _691716;
_691716 = 4 + _691703;
int _691710;
_691710 = 3 + _691703;
int _691704;
_691704 = 2 + _691703;
int _691927;
_691927 = 4 + _691914;
int _691921;
_691921 = 3 + _691914;
int _691915;
_691915 = 2 + _691914;
int _695450;
_695450 = 5 + _695437;
int _695444;
_695444 = 4 + _695437;
int _695438;
_695438 = 3 + _695437;
int _690977;
_690977 = 4 + _690964;
int _690971;
_690971 = 3 + _690964;
int _690965;
_690965 = 2 + _690964;
int _689393;
_689393 = 4 + _689380;
int _689387;
_689387 = 3 + _689380;
int _689381;
_689381 = 2 + _689380;
int _692740;
_692740 = 5 + _692727;
int _692734;
_692734 = 4 + _692727;
int _692728;
_692728 = 3 + _692727;
int _690097;
_690097 = 4 + _690084;
int _690091;
_690091 = 3 + _690084;
int _690085;
_690085 = 2 + _690084;
int _690238;
_690238 = 4 + _690225;
int _690232;
_690232 = 3 + _690225;
int _690226;
_690226 = 2 + _690225;
int _690625;
_690625 = 4 + _690612;
int _690619;
_690619 = 3 + _690612;
int _690613;
_690613 = 2 + _690612;
int _689499;
_689499 = 4 + _689486;
int _689493;
_689493 = 3 + _689486;
int _689487;
_689487 = 2 + _689486;
int _691646;
_691646 = 4 + _691633;
int _691640;
_691640 = 3 + _691633;
int _691634;
_691634 = 2 + _691633;
int _692103;
_692103 = 4 + _692090;
int _692097;
_692097 = 3 + _692090;
int _692091;
_692091 = 2 + _692090;
int _690660;
_690660 = 4 + _690647;
int _690654;
_690654 = 3 + _690647;
int _690648;
_690648 = 2 + _690647;
int _693444;
_693444 = 5 + _693431;
int _693438;
_693438 = 4 + _693431;
int _693432;
_693432 = 3 + _693431;
int _695169;
_695169 = 5 + _695156;
int _695163;
_695163 = 4 + _695156;
int _695157;
_695157 = 3 + _695156;
int _694958;
_694958 = 5 + _694945;
int _694952;
_694952 = 4 + _694945;
int _694946;
_694946 = 3 + _694945;
int _694148;
_694148 = 5 + _694135;
int _694142;
_694142 = 4 + _694135;
int _694136;
_694136 = 3 + _694135;
int _689428;
_689428 = 4 + _689415;
int _689422;
_689422 = 3 + _689415;
int _689416;
_689416 = 2 + _689415;
int _689639;
_689639 = 4 + _689626;
int _689633;
_689633 = 3 + _689626;
int _689627;
_689627 = 2 + _689626;
int _691787;
_691787 = 4 + _691774;
int _691781;
_691781 = 3 + _691774;
int _691775;
_691775 = 2 + _691774;
int _695380;
_695380 = 5 + _695367;
int _695374;
_695374 = 4 + _695367;
int _695368;
_695368 = 3 + _695367;
int _694500;
_694500 = 5 + _694487;
int _694494;
_694494 = 4 + _694487;
int _694488;
_694488 = 3 + _694487;
int _689041;
_689041 = 4 + _689028;
int _689035;
_689035 = 3 + _689028;
int _689029;
_689029 = 2 + _689028;
int _693479;
_693479 = 5 + _693466;
int _693473;
_693473 = 4 + _693466;
int _693467;
_693467 = 3 + _693466;
int _695556;
_695556 = 5 + _695543;
int _695550;
_695550 = 4 + _695543;
int _695544;
_695544 = 3 + _695543;
int _694078;
_694078 = 5 + _694065;
int _694072;
_694072 = 4 + _694065;
int _694066;
_694066 = 3 + _694065;
int _689323;
_689323 = 4 + _689310;
int _689317;
_689317 = 3 + _689310;
int _689311;
_689311 = 2 + _689310;
int _693198;
_693198 = 5 + _693185;
int _693192;
_693192 = 4 + _693185;
int _693186;
_693186 = 3 + _693185;
int _690308;
_690308 = 4 + _690295;
int _690302;
_690302 = 3 + _690295;
int _690296;
_690296 = 2 + _690295;
int _689463;
_689463 = 4 + _689450;
int _689457;
_689457 = 3 + _689450;
int _689451;
_689451 = 2 + _689450;
int _694852;
_694852 = 5 + _694839;
int _694846;
_694846 = 4 + _694839;
int _694840;
_694840 = 3 + _694839;
int _691540;
_691540 = 4 + _691527;
int _691534;
_691534 = 3 + _691527;
int _691528;
_691528 = 2 + _691527;
int _689076;
_689076 = 4 + _689063;
int _689070;
_689070 = 3 + _689063;
int _689064;
_689064 = 2 + _689063;
int _691435;
_691435 = 4 + _691422;
int _691429;
_691429 = 3 + _691422;
int _691423;
_691423 = 2 + _691422;
int _694887;
_694887 = 5 + _694874;
int _694881;
_694881 = 4 + _694874;
int _694875;
_694875 = 3 + _694874;
int _693655;
_693655 = 5 + _693642;
int _693649;
_693649 = 4 + _693642;
int _693643;
_693643 = 3 + _693642;
int _690062;
_690062 = 4 + _690049;
int _690056;
_690056 = 3 + _690049;
int _690050;
_690050 = 2 + _690049;
int _694183;
_694183 = 5 + _694170;
int _694177;
_694177 = 4 + _694170;
int _694171;
_694171 = 3 + _694170;
float zf_698581;
zf_698581 = zv_688764 - _698580;
int _691399;
_691399 = 4 + _691386;
int _691393;
_691393 = 3 + _691386;
int _691387;
_691387 = 2 + _691386;
int _689534;
_689534 = 4 + _689521;
int _689528;
_689528 = 3 + _689521;
int _689522;
_689522 = 2 + _689521;
int _691822;
_691822 = 4 + _691809;
int _691816;
_691816 = 3 + _691809;
int _691810;
_691810 = 2 + _691809;
int _695415;
_695415 = 5 + _695402;
int _695409;
_695409 = 4 + _695402;
int _695403;
_695403 = 3 + _695402;
int _689006;
_689006 = 4 + _688993;
int _689000;
_689000 = 3 + _688993;
int _688994;
_688994 = 2 + _688993;
int _691963;
_691963 = 4 + _691950;
int _691957;
_691957 = 3 + _691950;
int _691951;
_691951 = 2 + _691950;
int _689225;
_689225 = _689224 + _688766;
int _689753;
_689753 = _689752 + _688766;
int _689084;
_689084 = _689083 + _688766;
int _690422;
_690422 = _690421 + _688766;
int _690704;
_690704 = _690703 + _688766;
int _691161;
_691161 = _691160 + _688766;
int _692217;
_692217 = _692216 + _688766;
int _689964;
_689964 = _689963 + _688766;
int _690985;
_690985 = _690984 + _688766;
int _691091;
_691091 = _691090 + _688766;
int _690809;
_690809 = _690808 + _688766;
int _690246;
_690246 = _690245 + _688766;
int _692112;
_692112 = _692111 + _688766;
int _689929;
_689929 = _689928 + _688766;
int _691337;
_691337 = _691336 + _688766;
int _689331;
_689331 = _689330 + _688766;
int _690000;
_690000 = _689999 + _688766;
int _689859;
_689859 = _689858 + _688766;
int _691056;
_691056 = _691055 + _688766;
int _689788;
_689788 = _689787 + _688766;
int _691126;
_691126 = _691125 + _688766;
int _688908;
_688908 = _688907 + _688766;
int _689894;
_689894 = _689893 + _688766;
int _689260;
_689260 = _689259 + _688766;
int _691302;
_691302 = _691301 + _688766;
int _690492;
_690492 = _690491 + _688766;
int _691478;
_691478 = _691477 + _688766;
int _691584;
_691584 = _691583 + _688766;
int _689155;
_689155 = _689154 + _688766;
int _691654;
_691654 = _691653 + _688766;
int _691724;
_691724 = _691723 + _688766;
int _690457;
_690457 = _690456 + _688766;
int _692252;
_692252 = _692251 + _688766;
int _692147;
_692147 = _692146 + _688766;
int _691020;
_691020 = _691019 + _688766;
int _689120;
_689120 = _689119 + _688766;
int _689648;
_689648 = _689647 + _688766;
int _692006;
_692006 = _692005 + _688766;
int _689190;
_689190 = _689189 + _688766;
int _689824;
_689824 = _689823 + _688766;
int _691232;
_691232 = _691231 + _688766;
int _691575;
_691575 = 4 + _691562;
int _691569;
_691569 = 3 + _691562;
int _691563;
_691563 = 2 + _691562;
int _694289;
_694289 = 5 + _694276;
int _694283;
_694283 = 4 + _694276;
int _694277;
_694277 = 3 + _694276;
int _691098;
_691098 = _691090 + _688774;
int _689866;
_689866 = _689858 + _688774;
int _690253;
_690253 = _690245 + _688774;
int _689795;
_689795 = _689787 + _688774;
int _689901;
_689901 = _689893 + _688774;
int _690499;
_690499 = _690491 + _688774;
int _689655;
_689655 = _689647 + _688774;
int _691239;
_691239 = _691231 + _688774;
int _691485;
_691485 = _691477 + _688774;
int _689338;
_689338 = _689330 + _688774;
int _689760;
_689760 = _689752 + _688774;
int _689936;
_689936 = _689928 + _688774;
int _689971;
_689971 = _689963 + _688774;
int _691168;
_691168 = _691160 + _688774;
int _691344;
_691344 = _691336 + _688774;
int _690711;
_690711 = _690703 + _688774;
int _688915;
_688915 = _688907 + _688774;
int _691309;
_691309 = _691301 + _688774;
int _689127;
_689127 = _689119 + _688774;
int _691591;
_691591 = _691583 + _688774;
int _691731;
_691731 = _691723 + _688774;
int _690007;
_690007 = _689999 + _688774;
int _689267;
_689267 = _689259 + _688774;
int _690816;
_690816 = _690808 + _688774;
int _690992;
_690992 = _690984 + _688774;
int _691133;
_691133 = _691125 + _688774;
int _689162;
_689162 = _689154 + _688774;
int _692013;
_692013 = _692005 + _688774;
int _692154;
_692154 = _692146 + _688774;
int _690464;
_690464 = _690456 + _688774;
int _692119;
_692119 = _692111 + _688774;
int _689091;
_689091 = _689083 + _688774;
int _692224;
_692224 = _692216 + _688774;
int _692259;
_692259 = _692251 + _688774;
int _691661;
_691661 = _691653 + _688774;
int _691063;
_691063 = _691055 + _688774;
int _690429;
_690429 = _690421 + _688774;
int _691027;
_691027 = _691019 + _688774;
int _689831;
_689831 = _689823 + _688774;
int _689232;
_689232 = _689224 + _688774;
int _689197;
_689197 = _689189 + _688774;
int _694782;
_694782 = 5 + _694769;
int _694776;
_694776 = 4 + _694769;
int _694770;
_694770 = 3 + _694769;
int _694817;
_694817 = 5 + _694804;
int _694811;
_694811 = 4 + _694804;
int _694805;
_694805 = 3 + _694804;
int _689569;
_689569 = 4 + _689556;
int _689563;
_689563 = 3 + _689556;
int _689557;
_689557 = 2 + _689556;
int _693022;
_693022 = 5 + _693009;
int _693016;
_693016 = 4 + _693009;
int _693010;
_693010 = 3 + _693009;
int _688830;
_688830 = 4 + _688817;
int _688824;
_688824 = 3 + _688817;
int _688818;
_688818 = 2 + _688817;
int _694711;
_694711 = 5 + _694698;
int _694705;
_694705 = 4 + _694698;
int _694699;
_694699 = 3 + _694698;
int _693338;
_693338 = 5 + _693325;
int _693332;
_693332 = 4 + _693325;
int _693326;
_693326 = 3 + _693325;
int _695310;
_695310 = 5 + _695297;
int _695304;
_695304 = 4 + _695297;
int _695298;
_695298 = 3 + _695297;
int _690132;
_690132 = 4 + _690119;
int _690126;
_690126 = 3 + _690119;
int _690120;
_690120 = 2 + _690119;
int _689710;
_689710 = 4 + _689697;
int _689704;
_689704 = 3 + _689697;
int _689698;
_689698 = 2 + _689697;
int _690590;
_690590 = 4 + _690577;
int _690584;
_690584 = 3 + _690577;
int _690578;
_690578 = 2 + _690577;
int _690414;
_690414 = 4 + _690401;
int _690408;
_690408 = 3 + _690401;
int _690402;
_690402 = 2 + _690401;
int _695591;
_695591 = 5 + _695578;
int _695585;
_695585 = 4 + _695578;
int _695579;
_695579 = 3 + _695578;
int _690203;
_690203 = 4 + _690190;
int _690197;
_690197 = 3 + _690190;
int _690191;
_690191 = 2 + _690190;
float _698512;
_698512 = _698509 + _698511;
int _691598;
_691598 = _691583 + zi_688765;
int _691668;
_691668 = _691653 + zi_688765;
int _691937;
_691937 = 2 + _691936;
int _691944;
_691944 = 2 + _691943;
float _697360;
_697360 = _697358 + _697359;
float _697163;
_697163 = _697160 + _697162;
float _695860;
_695860 = _695858 + _695859;
float _698198;
_698198 = _698195 + _698197;
int _695754;
_695754 = _695739 + zi_688765;
int _695740;
_695740 = _695739 + _692289;
int _695747;
_695747 = _695739 + _692297;
int _695719;
_695719 = _695704 + zi_688765;
int _695705;
_695705 = _695704 + _692289;
int _695712;
_695712 = _695704 + _692297;
int _695684;
_695684 = _695669 + zi_688765;
int _695670;
_695670 = _695669 + _692289;
int _695677;
_695677 = _695669 + _692297;
int _695789;
_695789 = _695774 + zi_688765;
int _695782;
_695782 = _695774 + _692297;
int _695775;
_695775 = _695774 + _692289;
float _696532;
_696532 = _696529 + _696531;
float _696417;
_696417 = _696414 + _696416;
int _690388;
_690388 = 2 + _690387;
int _690395;
_690395 = 2 + _690394;
int _693924;
_693924 = _693909 + zi_688765;
int _693910;
_693910 = _693909 + _692289;
int _693917;
_693917 = _693909 + _692297;
int _693889;
_693889 = _693874 + zi_688765;
int _693875;
_693875 = _693874 + _692289;
int _693882;
_693882 = _693874 + _692297;
int _693959;
_693959 = _693944 + zi_688765;
int _693945;
_693945 = _693944 + _692289;
int _693952;
_693952 = _693944 + _692297;
int _694029;
_694029 = _694014 + zi_688765;
int _694015;
_694015 = _694014 + _692289;
int _694022;
_694022 = _694014 + _692297;
int _693994;
_693994 = _693979 + zi_688765;
int _693980;
_693980 = _693979 + _692289;
int _693987;
_693987 = _693979 + _692297;
int _689908;
_689908 = _689893 + zi_688765;
int _689873;
_689873 = _689858 + zi_688765;
int _689838;
_689838 = _689823 + zi_688765;
int _689978;
_689978 = _689963 + zi_688765;
int _689943;
_689943 = _689928 + zi_688765;
int _690141;
_690141 = 2 + _690140;
int _690148;
_690148 = 2 + _690147;
float _698228;
_698228 = _698226 + _698227;
float _696765;
_696765 = _696762 + _696764;
int _690177;
_690177 = 2 + _690176;
int _690184;
_690184 = 2 + _690183;
float _696051;
_696051 = _696049 + _696050;
float _696860;
_696860 = _696857 + _696859;
float _695901;
_695901 = _695899 + _695900;
float _698320;
_698320 = _698317 + _698319;
float _696320;
_696320 = _696317 + _696319;
int _691796;
_691796 = 2 + _691795;
int _691803;
_691803 = 2 + _691802;
float _696970;
_696970 = _696967 + _696969;
float _696727;
_696727 = _696725 + _696726;
float _696599;
_696599 = _696596 + _696598;
float _696458;
_696458 = _696455 + _696457;
int _689684;
_689684 = 2 + _689683;
int _689691;
_689691 = 2 + _689690;
int _692797;
_692797 = _692782 + zi_688765;
int _692783;
_692783 = _692782 + _692289;
int _692790;
_692790 = _692782 + _692297;
int _692762;
_692762 = _692747 + zi_688765;
int _692748;
_692748 = _692747 + _692289;
int _692755;
_692755 = _692747 + _692297;
int _692657;
_692657 = _692642 + zi_688765;
int _692643;
_692643 = _692642 + _692289;
int _692650;
_692650 = _692642 + _692297;
int _692692;
_692692 = _692677 + zi_688765;
int _692678;
_692678 = _692677 + _692289;
int _692685;
_692685 = _692677 + _692297;
float _697415;
_697415 = _697412 + _697414;
int _695121;
_695121 = _695106 + zi_688765;
int _695107;
_695107 = _695106 + _692289;
int _695114;
_695114 = _695106 + _692297;
int _695226;
_695226 = _695211 + zi_688765;
int _695212;
_695212 = _695211 + _692289;
int _695219;
_695219 = _695211 + _692297;
float _697798;
_697798 = _697795 + _697797;
int _691246;
_691246 = _691231 + zi_688765;
int _691351;
_691351 = _691336 + zi_688765;
int _691316;
_691316 = _691301 + zi_688765;
float _698103;
_698103 = _698100 + _698102;
int _692516;
_692516 = _692501 + zi_688765;
int _692502;
_692502 = _692501 + _692289;
int _692509;
_692509 = _692501 + _692297;
int _692586;
_692586 = _692571 + zi_688765;
int _692572;
_692572 = _692571 + _692289;
int _692579;
_692579 = _692571 + _692297;
int _692621;
_692621 = _692606 + zi_688765;
int _692607;
_692607 = _692606 + _692289;
int _692614;
_692614 = _692606 + _692297;
float _698281;
_698281 = _698278 + _698280;
int _693269;
_693269 = 2 * _693268;
int _693263;
_693263 = 2 * _693262;
int _693257;
_693257 = 2 * _693256;
float _696932;
_696932 = _696930 + _696931;
float _695913;
_695913 = _695911 + _695912;
float _698389;
_698389 = _698386 + _698388;
int _689297;
_689297 = 2 + _689296;
int _689304;
_689304 = 2 + _689303;
int _689367;
_689367 = 2 + _689366;
int _689374;
_689374 = 2 + _689373;
float _698019;
_698019 = _698016 + _698018;
float _696091;
_696091 = _696088 + _696090;
float _697781;
_697781 = _697778 + _697780;
float _697620;
_697620 = _697617 + _697619;
int _690951;
_690951 = 2 + _690950;
int _690958;
_690958 = 2 + _690957;
int _691119;
_691119 = 2 * _691118;
int _691113;
_691113 = 2 * _691112;
int _691107;
_691107 = 2 * _691106;
float _696615;
_696615 = _696613 + _696614;
int _694747;
_694747 = 2 * _694746;
int _694741;
_694741 = 2 * _694740;
int _694735;
_694735 = 2 * _694734;
int _690282;
_690282 = 2 + _690281;
int _690289;
_690289 = 2 + _690288;
float _696010;
_696010 = _696008 + _696009;
float _697676;
_697676 = _697674 + _697675;
int _691514;
_691514 = 2 + _691513;
int _691521;
_691521 = 2 + _691520;
int _688945;
_688945 = 2 + _688944;
int _688952;
_688952 = 2 + _688951;
float _698117;
_698117 = _698115 + _698116;
int _695522;
_695522 = 2 * _695521;
int _695516;
_695516 = 2 * _695515;
int _695510;
_695510 = 2 * _695509;
int _692042;
_692042 = 2 + _692041;
int _692049;
_692049 = 2 + _692048;
float _696560;
_696560 = _696557 + _696559;
float _696754;
_696754 = 6.000000e+00f * _696753;
float _696781;
_696781 = _696779 + _696780;
float _696313;
_696313 = _696311 + _696312;
int _690485;
_690485 = 2 * _690484;
int _690479;
_690479 = 2 * _690478;
int _690473;
_690473 = 2 * _690472;
float _697212;
_697212 = _697210 + _697211;
int _690317;
_690317 = 2 + _690316;
int _690324;
_690324 = 2 + _690323;
int _694325;
_694325 = 2 * _694324;
int _694319;
_694319 = 2 * _694318;
int _694313;
_694313 = 2 * _694312;
float _696226;
_696226 = _696223 + _696225;
int _691268;
_691268 = 2 + _691267;
int _691275;
_691275 = 2 + _691274;
float _696340;
_696340 = 6.000000e+00f * _696339;
float _695970;
_695970 = _695968 + _695969;
float _696505;
_696505 = _696503 + _696504;
float _698046;
_698046 = _698043 + _698045;
float _696019;
_696019 = _696016 + _696018;
int _689437;
_689437 = 2 + _689436;
int _689444;
_689444 = 2 + _689443;
float _697452;
_697452 = _697449 + _697451;
int _691549;
_691549 = 2 + _691548;
int _691556;
_691556 = 2 + _691555;
float _696143;
_696143 = _696140 + _696142;
int _692077;
_692077 = 2 + _692076;
int _692084;
_692084 = 2 + _692083;
float _697526;
_697526 = _697524 + _697525;
float _696184;
_696184 = _696181 + _696183;
int _695627;
_695627 = 2 * _695626;
int _695621;
_695621 = 2 * _695620;
int _695615;
_695615 = 2 * _695614;
int _691409;
_691409 = 2 + _691408;
int _691416;
_691416 = 2 + _691415;
float _698140;
_698140 = _698137 + _698139;
float _697065;
_697065 = _697062 + _697064;
int _693713;
_693713 = _693698 + zi_688765;
int _693699;
_693699 = _693698 + _692289;
int _693706;
_693706 = _693698 + _692297;
int _693783;
_693783 = _693768 + zi_688765;
int _693769;
_693769 = _693768 + _692289;
int _693776;
_693776 = _693768 + _692297;
int _693818;
_693818 = _693803 + zi_688765;
int _693804;
_693804 = _693803 + _692289;
int _693811;
_693811 = _693803 + _692297;
int _693748;
_693748 = _693733 + zi_688765;
int _693734;
_693734 = _693733 + _692289;
int _693741;
_693741 = _693733 + _692297;
int _693853;
_693853 = _693838 + zi_688765;
int _693839;
_693839 = _693838 + _692289;
int _693846;
_693846 = _693838 + _692297;
float _695977;
_695977 = _695974 + _695976;
int _695015;
_695015 = _695000 + zi_688765;
int _695001;
_695001 = _695000 + _692289;
int _695008;
_695008 = _695000 + _692297;
int _695085;
_695085 = _695070 + zi_688765;
int _695071;
_695071 = _695070 + _692289;
int _695078;
_695078 = _695070 + _692297;
int _695050;
_695050 = _695035 + zi_688765;
int _695036;
_695036 = _695035 + _692289;
int _695043;
_695043 = _695035 + _692297;
int _688980;
_688980 = 2 + _688979;
int _688987;
_688987 = 2 + _688986;
float _697055;
_697055 = _697053 + _697054;
float _698431;
_698431 = _698428 + _698430;
float _696353;
_696353 = _696351 + _696352;
float _695927;
_695927 = _695925 + _695926;
float _696877;
_696877 = _696875 + _696876;
float _696175;
_696175 = _696172 + _696174;
int _691690;
_691690 = 2 + _691689;
int _691697;
_691697 = 2 + _691696;
float _696489;
_696489 = _696486 + _696488;
int _689578;
_689578 = 2 + _689577;
int _689585;
_689585 = 2 + _689584;
int _695275;
_695275 = 2 * _695274;
int _695269;
_695269 = 2 * _695268;
int _695263;
_695263 = 2 * _695262;
int _689169;
_689169 = _689154 + zi_688765;
int _689274;
_689274 = _689259 + zi_688765;
int _689204;
_689204 = _689189 + zi_688765;
int _689239;
_689239 = _689224 + zi_688765;
int _689134;
_689134 = _689119 + zi_688765;
float _697188;
_697188 = _697185 + _697187;
float _698270;
_698270 = 6.000000e+00f * _698269;
int _689112;
_689112 = 2 * _689111;
int _689106;
_689106 = 2 * _689105;
int _689100;
_689100 = 2 * _689099;
int _690732;
_690732 = 2 * _690731;
int _690726;
_690726 = 2 * _690725;
int _690720;
_690720 = 2 * _690719;
float _698527;
_698527 = _698524 + _698526;
float _696684;
_696684 = _696682 + _696683;
float _698552;
_698552 = _698549 + _698551;
float _697429;
_697429 = _697427 + _697428;
float _697755;
_697755 = _697752 + _697754;
float _698543;
_698543 = _698541 + _698542;
float _697177;
_697177 = _697174 + _697176;
float _698400;
_698400 = _698397 + _698399;
float _695950;
_695950 = _695947 + _695949;
int _691752;
_691752 = 2 * _691751;
int _691746;
_691746 = 2 * _691745;
int _691740;
_691740 = 2 * _691739;
int _692445;
_692445 = _692430 + zi_688765;
int _692431;
_692431 = _692430 + _692289;
int _692438;
_692438 = _692430 + _692297;
int _692410;
_692410 = _692395 + zi_688765;
int _692396;
_692396 = _692395 + _692289;
int _692403;
_692403 = _692395 + _692297;
int _692305;
_692305 = _692287 + zi_688765;
int _692290;
_692290 = _692287 + _692289;
int _692298;
_692298 = _692287 + _692297;
int _692375;
_692375 = _692360 + zi_688765;
int _692361;
_692361 = _692360 + _692289;
int _692368;
_692368 = _692360 + _692297;
int _692340;
_692340 = _692325 + zi_688765;
int _692326;
_692326 = _692325 + _692289;
int _692333;
_692333 = _692325 + _692297;
int _689508;
_689508 = 2 + _689507;
int _689515;
_689515 = 2 + _689514;
float _697300;
_697300 = _697297 + _697299;
float _698212;
_698212 = _698209 + _698211;
float _697535;
_697535 = _697532 + _697534;
float _695874;
_695874 = _695872 + _695873;
int _689781;
_689781 = 2 * _689780;
int _689775;
_689775 = 2 * _689774;
int _689769;
_689769 = 2 * _689768;
float _698085;
_698085 = _698082 + _698084;
float _697988;
_697988 = _697985 + _697987;
float _697496;
_697496 = _697493 + _697495;
float _698256;
_698256 = 4.000000e+00f * _698255;
float _697289;
_697289 = _697286 + _697288;
int _691154;
_691154 = 2 * _691153;
int _691148;
_691148 = 2 * _691147;
int _691142;
_691142 = 2 * _691141;
float _698469;
_698469 = _698466 + _698468;
int _691373;
_691373 = 2 + _691372;
int _691380;
_691380 = 2 + _691379;
int _691761;
_691761 = 2 + _691760;
int _691768;
_691768 = 2 + _691767;
float _696239;
_696239 = _696236 + _696238;
float _696279;
_696279 = _696276 + _696278;
int _689676;
_689676 = 2 * _689675;
int _689670;
_689670 = 2 * _689669;
int _689664;
_689664 = 2 * _689663;
float _696365;
_696365 = _696362 + _696364;
int _693375;
_693375 = 2 * _693374;
int _693369;
_693369 = 2 * _693368;
int _693363;
_693363 = 2 * _693362;
float _697512;
_697512 = _697510 + _697511;
float _696449;
_696449 = _696446 + _696448;
float _697926;
_697926 = _697924 + _697925;
float _697224;
_697224 = _697222 + _697223;
int _692231;
_692231 = _692216 + zi_688765;
int _692266;
_692266 = _692251 + zi_688765;
int _692161;
_692161 = _692146 + zi_688765;
int _692126;
_692126 = _692111 + zi_688765;
float _697001;
_697001 = _696999 + _697000;
float _696298;
_696298 = _696296 + _696297;
float _698348;
_698348 = _698345 + _698347;
int _691972;
_691972 = 2 + _691971;
int _691979;
_691979 = 2 + _691978;
float _696134;
_696134 = _696132 + _696133;
float _697314;
_697314 = _697311 + _697313;
int _690520;
_690520 = 2 * _690519;
int _690514;
_690514 = 2 * _690513;
int _690508;
_690508 = 2 * _690507;
float _698062;
_698062 = _698060 + _698061;
int _694571;
_694571 = 2 * _694570;
int _694565;
_694565 = 2 * _694564;
int _694559;
_694559 = 2 * _694558;
float _698414;
_698414 = _698411 + _698413;
float _696256;
_696256 = _696254 + _696255;
int _689816;
_689816 = 2 * _689815;
int _689810;
_689810 = 2 * _689809;
int _689804;
_689804 = 2 * _689803;
int _694219;
_694219 = 2 * _694218;
int _694213;
_694213 = 2 * _694212;
int _694207;
_694207 = 2 * _694206;
float _697080;
_697080 = _697077 + _697079;
float _697814;
_697814 = _697812 + _697813;
float _697481;
_697481 = _697478 + _697480;
float _698571;
_698571 = _698569 + _698570;
float _696548;
_696548 = _696546 + _696547;
float _698337;
_698337 = 6.000000e+00f * _698336;
float _696892;
_696892 = 6.000000e+00f * _696891;
int _689543;
_689543 = 2 + _689542;
int _689550;
_689550 = 2 + _689549;
float _697550;
_697550 = _697547 + _697549;
float _696403;
_696403 = _696400 + _696402;
float _696831;
_696831 = _696828 + _696830;
float _696157;
_696157 = _696154 + _696156;
float _696584;
_696584 = _696581 + _696583;
int _692183;
_692183 = 2 + _692182;
int _692190;
_692190 = 2 + _692189;
float _698184;
_698184 = _698181 + _698183;
float _697974;
_697974 = _697971 + _697973;
int _690036;
_690036 = 2 + _690035;
int _690043;
_690043 = 2 + _690042;
float _696106;
_696106 = _696103 + _696105;
float _698005;
_698005 = _698002 + _698004;
float _696668;
_696668 = _696665 + _696667;
int _689719;
_689719 = 2 + _689718;
int _689726;
_689726 = 2 + _689725;
float _698243;
_698243 = _698241 + _698242;
int _690916;
_690916 = 2 + _690915;
int _690923;
_690923 = 2 + _690922;
float _697912;
_697912 = _697910 + _697911;
int _691506;
_691506 = 2 * _691505;
int _691500;
_691500 = 2 * _691499;
int _691494;
_691494 = 2 * _691493;
float _697264;
_697264 = _697261 + _697263;
float _696981;
_696981 = _696978 + _696980;
int _694536;
_694536 = 2 * _694535;
int _694530;
_694530 = 2 * _694529;
int _694524;
_694524 = 2 * _694523;
float _698483;
_698483 = _698480 + _698482;
float _697850;
_697850 = _697847 + _697849;
float _697137;
_697137 = _697134 + _697136;
float _696641;
_696641 = _696638 + _696640;
float _696696;
_696696 = _696693 + _696695;
int _689473;
_689473 = 2 + _689472;
int _689480;
_689480 = 2 + _689479;
float _696576;
_696576 = _696574 + _696575;
float _698292;
_698292 = _698289 + _698291;
int _689359;
_689359 = 2 * _689358;
int _689353;
_689353 = 2 * _689352;
int _689347;
_689347 = 2 * _689346;
float _698071;
_698071 = _698068 + _698070;
float _697013;
_697013 = _697011 + _697012;
int _690450;
_690450 = 2 * _690449;
int _690444;
_690444 = 2 * _690443;
int _690438;
_690438 = 2 * _690437;
float _696900;
_696900 = _696897 + _696899;
int _689613;
_689613 = 2 + _689612;
int _689620;
_689620 = 2 + _689619;
float _698377;
_698377 = _698374 + _698376;
int _691620;
_691620 = 2 + _691619;
int _691627;
_691627 = 2 + _691626;
float _697965;
_697965 = _697962 + _697964;
float _696944;
_696944 = _696942 + _696943;
int _690529;
_690529 = 2 + _690528;
int _690536;
_690536 = 2 + _690535;
int _695487;
_695487 = 2 * _695486;
int _695481;
_695481 = 2 * _695480;
int _695475;
_695475 = 2 * _695474;
float _696270;
_696270 = _696268 + _696269;
int _690353;
_690353 = 2 + _690352;
int _690360;
_690360 = 2 + _690359;
float _697568;
_697568 = 4.000000e+00f * _697567;
float _697374;
_697374 = _697372 + _697373;
int _691197;
_691197 = 2 + _691196;
int _691204;
_691204 = 2 + _691203;
float _695834;
_695834 = _695832 + _695833;
int _689402;
_689402 = 2 + _689401;
int _689409;
_689409 = 2 + _689408;
int _690071;
_690071 = 2 + _690070;
int _690078;
_690078 = 2 + _690077;
int _690106;
_690106 = 2 + _690105;
int _690113;
_690113 = 2 + _690112;
float _696629;
_696629 = _696627 + _696628;
int _689050;
_689050 = 2 + _689049;
int _689057;
_689057 = 2 + _689056;
int _689015;
_689015 = 2 + _689014;
int _689022;
_689022 = 2 + _689021;
float _696796;
_696796 = _696794 + _696795;
float _696079;
_696079 = _696077 + _696078;
int _690881;
_690881 = 2 + _690880;
int _690888;
_690888 = 2 + _690887;
float _698036;
_698036 = _698034 + _698035;
int _693410;
_693410 = 2 * _693409;
int _693404;
_693404 = 2 * _693403;
int _693398;
_693398 = 2 * _693397;
float _698502;
_698502 = _698500 + _698501;
float _697649;
_697649 = 6.000000e+00f * _697648;
float _697441;
_697441 = _697438 + _697440;
int _692917;
_692917 = 2 * _692916;
int _692911;
_692911 = 2 * _692910;
int _692905;
_692905 = 2 * _692904;
float _697348;
_697348 = _697346 + _697347;
int _691084;
_691084 = 2 * _691083;
int _691078;
_691078 = 2 * _691077;
int _691072;
_691072 = 2 * _691071;
float _696475;
_696475 = _696472 + _696474;
float _697041;
_697041 = _697039 + _697040;
float _697952;
_697952 = _697949 + _697951;
float _697745;
_697745 = _697743 + _697744;
float _697663;
_697663 = 4.000000e+00f * _697662;
float _697689;
_697689 = _697686 + _697688;
int _690564;
_690564 = 2 + _690563;
int _690571;
_690571 = 2 + _690570;
int _690634;
_690634 = 2 + _690633;
int _690641;
_690641 = 2 + _690640;
int _690599;
_690599 = 2 + _690598;
int _690606;
_690606 = 2 + _690605;
int _690669;
_690669 = 2 + _690668;
int _690676;
_690676 = 2 + _690675;
float _696204;
_696204 = 6.000000e+00f * _696203;
int _691444;
_691444 = 2 + _691443;
int _691451;
_691451 = 2 + _691450;
float _696823;
_696823 = 6.000000e+00f * _696822;
int _694466;
_694466 = 2 * _694465;
int _694460;
_694460 = 2 * _694459;
int _694454;
_694454 = 2 * _694453;
float _697869;
_697869 = _697867 + _697868;
float _697772;
_697772 = _697770 + _697771;
float _697595;
_697595 = _697593 + _697594;
float _697632;
_697632 = _697629 + _697631;
int _692987;
_692987 = 2 * _692986;
int _692981;
_692981 = 2 * _692980;
int _692975;
_692975 = 2 * _692974;
int _690845;
_690845 = 2 + _690844;
int _690852;
_690852 = 2 + _690851;
int _690740;
_690740 = 2 + _690739;
int _690747;
_690747 = 2 + _690746;
int _690775;
_690775 = 2 + _690774;
int _690782;
_690782 = 2 + _690781;
float _696065;
_696065 = _696063 + _696064;
int _693234;
_693234 = 2 * _693233;
int _693228;
_693228 = 2 * _693227;
int _693222;
_693222 = 2 * _693221;
int _691013;
_691013 = 2 * _691012;
int _691007;
_691007 = 2 * _691006;
int _691001;
_691001 = 2 * _691000;
float _696121;
_696121 = 4.000000e+00f * _696120;
float _697609;
_697609 = _697607 + _697608;
float _696739;
_696739 = _696737 + _696738;
int _690837;
_690837 = 2 * _690836;
int _690831;
_690831 = 2 * _690830;
int _690825;
_690825 = 2 * _690824;
float _697027;
_697027 = _697025 + _697026;
float _698461;
_698461 = 4.000000e+00f * _698460;
float _697250;
_697250 = _697247 + _697249;
float _696218;
_696218 = 4.000000e+00f * _696217;
float _696959;
_696959 = 6.000000e+00f * _696958;
float _696522;
_696522 = _696520 + _696521;
int _688839;
_688839 = 2 + _688838;
int _688846;
_688846 = 2 + _688845;
int _688768;
_688768 = 2 + _688767;
int _688776;
_688776 = 2 + _688775;
int _688874;
_688874 = 2 + _688873;
int _688881;
_688881 = 2 + _688880;
int _688804;
_688804 = 2 + _688803;
int _688811;
_688811 = 2 + _688810;
float _697124;
_697124 = _697122 + _697123;
float _698364;
_698364 = _698362 + _698363;
float _697842;
_697842 = 4.000000e+00f * _697841;
float _696808;
_696808 = _696806 + _696807;
int _690212;
_690212 = 2 + _690211;
int _690219;
_690219 = 2 + _690218;
float _697097;
_697097 = 6.000000e+00f * _697096;
int _691189;
_691189 = 2 * _691188;
int _691183;
_691183 = 2 * _691182;
int _691177;
_691177 = 2 * _691176;
int _691048;
_691048 = 2 * _691047;
int _691042;
_691042 = 2 * _691041;
int _691036;
_691036 = 2 * _691035;
float _697703;
_697703 = _697701 + _697702;
int _690274;
_690274 = 2 * _690273;
int _690268;
_690268 = 2 * _690267;
int _690262;
_690262 = 2 * _690261;
int _691901;
_691901 = 2 + _691900;
int _691908;
_691908 = 2 + _691907;
int _691866;
_691866 = 2 + _691865;
int _691873;
_691873 = 2 + _691872;
int _691831;
_691831 = 2 + _691830;
int _691838;
_691838 = 2 + _691837;
float _697729;
_697729 = _697726 + _697728;
int _694642;
_694642 = 2 * _694641;
int _694636;
_694636 = 2 * _694635;
int _694630;
_694630 = 2 * _694629;
float _697900;
_697900 = _697898 + _697899;
float _697239;
_697239 = 6.000000e+00f * _697238;
float _695994;
_695994 = _695991 + _695993;
float _697388;
_697388 = _697386 + _697387;
float _697111;
_697111 = 4.000000e+00f * _697110;
float _697582;
_697582 = 6.000000e+00f * _697581;
float _698310;
_698310 = _698308 + _698309;
int _693551;
_693551 = 2 * _693550;
int _693545;
_693545 = 2 * _693544;
int _693539;
_693539 = 2 * _693538;
float _697149;
_697149 = _697146 + _697148;
float _697715;
_697715 = _697712 + _697714;
float _698129;
_698129 = _698126 + _698128;
float _697941;
_697941 = 4.000000e+00f * _697940;
float _695846;
_695846 = _695844 + _695845;
float _696394;
_696394 = _696392 + _696393;
float _697843;
_697843 = _697829 + _697842;
float _698446;
_698446 = _698443 + _698445;
int _688936;
_688936 = 2 * _688935;
int _688930;
_688930 = 2 * _688929;
int _688924;
_688924 = 2 * _688923;
int _694114;
_694114 = 2 * _694113;
int _694108;
_694108 = 2 * _694107;
int _694102;
_694102 = 2 * _694101;
float _695942;
_695942 = 4.000000e+00f * _695941;
float _696710;
_696710 = _696707 + _696709;
int _692034;
_692034 = 2 * _692033;
int _692028;
_692028 = 2 * _692027;
int _692022;
_692022 = 2 * _692021;
int _693093;
_693093 = 2 * _693092;
int _693087;
_693087 = 2 * _693086;
int _693081;
_693081 = 2 * _693080;
int _692882;
_692882 = 2 * _692881;
int _692876;
_692876 = 2 * _692875;
int _692870;
_692870 = 2 * _692869;
int _694255;
_694255 = 2 * _694254;
int _694249;
_694249 = 2 * _694248;
int _694243;
_694243 = 2 * _694242;
int _691471;
_691471 = 2 * _691470;
int _691465;
_691465 = 2 * _691464;
int _691459;
_691459 = 2 * _691458;
int _692952;
_692952 = 2 * _692951;
int _692946;
_692946 = 2 * _692945;
int _692940;
_692940 = 2 * _692939;
int _690908;
_690908 = 2 * _690907;
int _690902;
_690902 = 2 * _690901;
int _690896;
_690896 = 2 * _690895;
int _691224;
_691224 = 2 * _691223;
int _691218;
_691218 = 2 * _691217;
int _691212;
_691212 = 2 * _691211;
int _688901;
_688901 = 2 * _688900;
int _688895;
_688895 = 2 * _688894;
int _688889;
_688889 = 2 * _688888;
int _690028;
_690028 = 2 * _690027;
int _690022;
_690022 = 2 * _690021;
int _690016;
_690016 = 2 * _690015;
int _693058;
_693058 = 2 * _693057;
int _693052;
_693052 = 2 * _693051;
int _693046;
_693046 = 2 * _693045;
int _692069;
_692069 = 2 * _692068;
int _692063;
_692063 = 2 * _692062;
int _692057;
_692057 = 2 * _692056;
int _694923;
_694923 = 2 * _694922;
int _694917;
_694917 = 2 * _694916;
int _694911;
_694911 = 2 * _694910;
int _693128;
_693128 = 2 * _693127;
int _693122;
_693122 = 2 * _693121;
int _693116;
_693116 = 2 * _693115;
int _695346;
_695346 = 2 * _695345;
int _695340;
_695340 = 2 * _695339;
int _695334;
_695334 = 2 * _695333;
int _691999;
_691999 = 2 * _691998;
int _691993;
_691993 = 2 * _691992;
int _691987;
_691987 = 2 * _691986;
int _688866;
_688866 = 2 * _688865;
int _688860;
_688860 = 2 * _688859;
int _688854;
_688854 = 2 * _688853;
int _690380;
_690380 = 2 * _690379;
int _690374;
_690374 = 2 * _690373;
int _690368;
_690368 = 2 * _690367;
int _694677;
_694677 = 2 * _694676;
int _694671;
_694671 = 2 * _694670;
int _694665;
_694665 = 2 * _694664;
int _693515;
_693515 = 2 * _693514;
int _693509;
_693509 = 2 * _693508;
int _693503;
_693503 = 2 * _693502;
int _693163;
_693163 = 2 * _693162;
int _693157;
_693157 = 2 * _693156;
int _693151;
_693151 = 2 * _693150;
int _695205;
_695205 = 2 * _695204;
int _695199;
_695199 = 2 * _695198;
int _695193;
_695193 = 2 * _695192;
int _690767;
_690767 = 2 * _690766;
int _690761;
_690761 = 2 * _690760;
int _690755;
_690755 = 2 * _690754;
int _688972;
_688972 = 2 * _688971;
int _688966;
_688966 = 2 * _688965;
int _688960;
_688960 = 2 * _688959;
int _688796;
_688796 = 2 * _688795;
int _688790;
_688790 = 2 * _688789;
int _688784;
_688784 = 2 * _688783;
int _690872;
_690872 = 2 * _690871;
int _690866;
_690866 = 2 * _690865;
int _690860;
_690860 = 2 * _690859;
int _689605;
_689605 = 2 * _689604;
int _689599;
_689599 = 2 * _689598;
int _689593;
_689593 = 2 * _689592;
int _693691;
_693691 = 2 * _693690;
int _693685;
_693685 = 2 * _693684;
int _693679;
_693679 = 2 * _693678;
int _693621;
_693621 = 2 * _693620;
int _693615;
_693615 = 2 * _693614;
int _693609;
_693609 = 2 * _693608;
int _692495;
_692495 = 2 * _692494;
int _692489;
_692489 = 2 * _692488;
int _692483;
_692483 = 2 * _692482;
int _693304;
_693304 = 2 * _693303;
int _693298;
_693298 = 2 * _693297;
int _693292;
_693292 = 2 * _693291;
int _692847;
_692847 = 2 * _692846;
int _692841;
_692841 = 2 * _692840;
int _692835;
_692835 = 2 * _692834;
int _692565;
_692565 = 2 * _692564;
int _692559;
_692559 = 2 * _692558;
int _692553;
_692553 = 2 * _692552;
int _694360;
_694360 = 2 * _694359;
int _694354;
_694354 = 2 * _694353;
int _694348;
_694348 = 2 * _694347;
int _693586;
_693586 = 2 * _693585;
int _693580;
_693580 = 2 * _693579;
int _693574;
_693574 = 2 * _693573;
int _690556;
_690556 = 2 * _690555;
int _690550;
_690550 = 2 * _690549;
int _690544;
_690544 = 2 * _690543;
int _691295;
_691295 = 2 * _691294;
int _691289;
_691289 = 2 * _691288;
int _691283;
_691283 = 2 * _691282;
int _694994;
_694994 = 2 * _694993;
int _694988;
_694988 = 2 * _694987;
int _694982;
_694982 = 2 * _694981;
int _694395;
_694395 = 2 * _694394;
int _694389;
_694389 = 2 * _694388;
int _694383;
_694383 = 2 * _694382;
int _695663;
_695663 = 2 * _695662;
int _695657;
_695657 = 2 * _695656;
int _695651;
_695651 = 2 * _695650;
int _694607;
_694607 = 2 * _694606;
int _694601;
_694601 = 2 * _694600;
int _694595;
_694595 = 2 * _694594;
int _691858;
_691858 = 2 * _691857;
int _691852;
_691852 = 2 * _691851;
int _691846;
_691846 = 2 * _691845;
int _691893;
_691893 = 2 * _691892;
int _691887;
_691887 = 2 * _691886;
int _691881;
_691881 = 2 * _691880;
int _690696;
_690696 = 2 * _690695;
int _690690;
_690690 = 2 * _690689;
int _690684;
_690684 = 2 * _690683;
int _695642;
_695642 = _695634 + _692297;
int _692544;
_692544 = _692536 + _692297;
int _694515;
_694515 = _694507 + _692297;
int _693494;
_693494 = _693486 + _692297;
int _694339;
_694339 = _694331 + _692297;
int _694058;
_694058 = _694050 + _692297;
int _694656;
_694656 = _694648 + _692297;
int _694480;
_694480 = _694472 + _692297;
int _694762;
_694762 = _694754 + _692297;
int _695466;
_695466 = _695458 + _692297;
int _695395;
_695395 = _695387 + _692297;
int _693178;
_693178 = _693170 + _692297;
int _693459;
_693459 = _693451 + _692297;
int _694304;
_694304 = _694296 + _692297;
int _695254;
_695254 = _695246 + _692297;
int _694550;
_694550 = _694542 + _692297;
int _693248;
_693248 = _693240 + _692297;
int _693670;
_693670 = _693662 + _692297;
int _692861;
_692861 = _692853 + _692297;
int _693600;
_693600 = _693592 + _692297;
int _694867;
_694867 = _694859 + _692297;
int _694621;
_694621 = _694613 + _692297;
int _693107;
_693107 = _693099 + _692297;
int _693213;
_693213 = _693205 + _692297;
int _693635;
_693635 = _693627 + _692297;
int _694163;
_694163 = _694155 + _692297;
int _695430;
_695430 = _695422 + _692297;
int _693142;
_693142 = _693134 + _692297;
int _695149;
_695149 = _695141 + _692297;
int _695325;
_695325 = _695317 + _692297;
int _693002;
_693002 = _692994 + _692297;
int _695536;
_695536 = _695528 + _692297;
int _693530;
_693530 = _693522 + _692297;
int _692826;
_692826 = _692818 + _692297;
int _694128;
_694128 = _694120 + _692297;
int _694234;
_694234 = _694226 + _692297;
int _693389;
_693389 = _693381 + _692297;
int _694938;
_694938 = _694930 + _692297;
int _692931;
_692931 = _692923 + _692297;
int _694374;
_694374 = _694366 + _692297;
int _693037;
_693037 = _693029 + _692297;
int _695360;
_695360 = _695352 + _692297;
int _693424;
_693424 = _693416 + _692297;
int _695184;
_695184 = _695176 + _692297;
int _694832;
_694832 = _694824 + _692297;
int _694410;
_694410 = _694402 + _692297;
int _694797;
_694797 = _694789 + _692297;
int _695571;
_695571 = _695563 + _692297;
int _694445;
_694445 = _694437 + _692297;
int _692966;
_692966 = _692958 + _692297;
int _694691;
_694691 = _694683 + _692297;
int _692474;
_692474 = _692466 + _692297;
int _693283;
_693283 = _693275 + _692297;
int _692720;
_692720 = _692712 + _692297;
int _693354;
_693354 = _693346 + _692297;
int _693318;
_693318 = _693310 + _692297;
int _694198;
_694198 = _694190 + _692297;
int _695290;
_695290 = _695282 + _692297;
int _693565;
_693565 = _693557 + _692297;
int _694973;
_694973 = _694965 + _692297;
int _694726;
_694726 = _694718 + _692297;
int _693072;
_693072 = _693064 + _692297;
int _695501;
_695501 = _695493 + _692297;
int _692896;
_692896 = _692888 + _692297;
int _694586;
_694586 = _694578 + _692297;
int _694093;
_694093 = _694085 + _692297;
int _694902;
_694902 = _694894 + _692297;
int _695606;
_695606 = _695598 + _692297;
int _694269;
_694269 = _694261 + _692297;
int _693276;
_693276 = _693275 + _692289;
int _694156;
_694156 = _694155 + _692289;
int _695353;
_695353 = _695352 + _692289;
int _694966;
_694966 = _694965 + _692289;
int _694790;
_694790 = _694789 + _692289;
int _694755;
_694755 = _694754 + _692289;
int _694227;
_694227 = _694226 + _692289;
int _695564;
_695564 = _695563 + _692289;
int _693206;
_693206 = _693205 + _692289;
int _693100;
_693100 = _693099 + _692289;
int _694543;
_694543 = _694542 + _692289;
int _694614;
_694614 = _694613 + _692289;
int _694684;
_694684 = _694683 + _692289;
int _692995;
_692995 = _692994 + _692289;
int _692959;
_692959 = _692958 + _692289;
int _692924;
_692924 = _692923 + _692289;
int _693417;
_693417 = _693416 + _692289;
int _693487;
_693487 = _693486 + _692289;
int _693171;
_693171 = _693170 + _692289;
int _695423;
_695423 = _695422 + _692289;
int _692713;
_692713 = _692712 + _692289;
int _695177;
_695177 = _695176 + _692289;
int _694191;
_694191 = _694190 + _692289;
int _692889;
_692889 = _692888 + _692289;
int _695388;
_695388 = _695387 + _692289;
int _694051;
_694051 = _694050 + _692289;
int _693311;
_693311 = _693310 + _692289;
int _695318;
_695318 = _695317 + _692289;
int _694579;
_694579 = _694578 + _692289;
int _693065;
_693065 = _693064 + _692289;
int _693347;
_693347 = _693346 + _692289;
int _694262;
_694262 = _694261 + _692289;
int _692819;
_692819 = _692818 + _692289;
int _693135;
_693135 = _693134 + _692289;
int _695635;
_695635 = _695634 + _692289;
int _694508;
_694508 = _694507 + _692289;
int _692467;
_692467 = _692466 + _692289;
int _694825;
_694825 = _694824 + _692289;
int _695283;
_695283 = _695282 + _692289;
int _694297;
_694297 = _694296 + _692289;
int _693523;
_693523 = _693522 + _692289;
int _694895;
_694895 = _694894 + _692289;
int _694121;
_694121 = _694120 + _692289;
int _695142;
_695142 = _695141 + _692289;
int _693593;
_693593 = _693592 + _692289;
int _693241;
_693241 = _693240 + _692289;
int _694473;
_694473 = _694472 + _692289;
int _694719;
_694719 = _694718 + _692289;
int _695459;
_695459 = _695458 + _692289;
int _693030;
_693030 = _693029 + _692289;
int _695247;
_695247 = _695246 + _692289;
int _694649;
_694649 = _694648 + _692289;
int _694332;
_694332 = _694331 + _692289;
int _693452;
_693452 = _693451 + _692289;
int _695599;
_695599 = _695598 + _692289;
int _693628;
_693628 = _693627 + _692289;
int _692854;
_692854 = _692853 + _692289;
int _694438;
_694438 = _694437 + _692289;
int _693663;
_693663 = _693662 + _692289;
int _693558;
_693558 = _693557 + _692289;
int _694086;
_694086 = _694085 + _692289;
int _693382;
_693382 = _693381 + _692289;
int _692537;
_692537 = _692536 + _692289;
int _695529;
_695529 = _695528 + _692289;
int _695494;
_695494 = _695493 + _692289;
int _694931;
_694931 = _694930 + _692289;
int _694367;
_694367 = _694366 + _692289;
int _694403;
_694403 = _694402 + _692289;
int _694860;
_694860 = _694859 + _692289;
int _694431;
_694431 = 2 * _694430;
int _694425;
_694425 = 2 * _694424;
int _694419;
_694419 = 2 * _694418;
int _690344;
_690344 = 2 * _690343;
int _690338;
_690338 = 2 * _690337;
int _690332;
_690332 = 2 * _690331;
int _690802;
_690802 = 2 * _690801;
int _690796;
_690796 = 2 * _690795;
int _690790;
_690790 = 2 * _690789;
int _692210;
_692210 = 2 * _692209;
int _692204;
_692204 = 2 * _692203;
int _692198;
_692198 = 2 * _692197;
int _689746;
_689746 = 2 * _689745;
int _689740;
_689740 = 2 * _689739;
int _689734;
_689734 = 2 * _689733;
int _690943;
_690943 = 2 * _690942;
int _690937;
_690937 = 2 * _690936;
int _690931;
_690931 = 2 * _690930;
int _690168;
_690168 = 2 * _690167;
int _690162;
_690162 = 2 * _690161;
int _690156;
_690156 = 2 * _690155;
int _691717;
_691717 = 2 * _691716;
int _691711;
_691711 = 2 * _691710;
int _691705;
_691705 = 2 * _691704;
int _691928;
_691928 = 2 * _691927;
int _691922;
_691922 = 2 * _691921;
int _691916;
_691916 = 2 * _691915;
int _695451;
_695451 = 2 * _695450;
int _695445;
_695445 = 2 * _695444;
int _695439;
_695439 = 2 * _695438;
int _690978;
_690978 = 2 * _690977;
int _690972;
_690972 = 2 * _690971;
int _690966;
_690966 = 2 * _690965;
int _689394;
_689394 = 2 * _689393;
int _689388;
_689388 = 2 * _689387;
int _689382;
_689382 = 2 * _689381;
int _692741;
_692741 = 2 * _692740;
int _692735;
_692735 = 2 * _692734;
int _692729;
_692729 = 2 * _692728;
int _690098;
_690098 = 2 * _690097;
int _690092;
_690092 = 2 * _690091;
int _690086;
_690086 = 2 * _690085;
int _690239;
_690239 = 2 * _690238;
int _690233;
_690233 = 2 * _690232;
int _690227;
_690227 = 2 * _690226;
int _690626;
_690626 = 2 * _690625;
int _690620;
_690620 = 2 * _690619;
int _690614;
_690614 = 2 * _690613;
int _689500;
_689500 = 2 * _689499;
int _689494;
_689494 = 2 * _689493;
int _689488;
_689488 = 2 * _689487;
int _691647;
_691647 = 2 * _691646;
int _691641;
_691641 = 2 * _691640;
int _691635;
_691635 = 2 * _691634;
int _692104;
_692104 = 2 * _692103;
int _692098;
_692098 = 2 * _692097;
int _692092;
_692092 = 2 * _692091;
int _690661;
_690661 = 2 * _690660;
int _690655;
_690655 = 2 * _690654;
int _690649;
_690649 = 2 * _690648;
int _693445;
_693445 = 2 * _693444;
int _693439;
_693439 = 2 * _693438;
int _693433;
_693433 = 2 * _693432;
int _695170;
_695170 = 2 * _695169;
int _695164;
_695164 = 2 * _695163;
int _695158;
_695158 = 2 * _695157;
int _694959;
_694959 = 2 * _694958;
int _694953;
_694953 = 2 * _694952;
int _694947;
_694947 = 2 * _694946;
int _694149;
_694149 = 2 * _694148;
int _694143;
_694143 = 2 * _694142;
int _694137;
_694137 = 2 * _694136;
int _689429;
_689429 = 2 * _689428;
int _689423;
_689423 = 2 * _689422;
int _689417;
_689417 = 2 * _689416;
int _689640;
_689640 = 2 * _689639;
int _689634;
_689634 = 2 * _689633;
int _689628;
_689628 = 2 * _689627;
int _691788;
_691788 = 2 * _691787;
int _691782;
_691782 = 2 * _691781;
int _691776;
_691776 = 2 * _691775;
int _695381;
_695381 = 2 * _695380;
int _695375;
_695375 = 2 * _695374;
int _695369;
_695369 = 2 * _695368;
int _694501;
_694501 = 2 * _694500;
int _694495;
_694495 = 2 * _694494;
int _694489;
_694489 = 2 * _694488;
int _689042;
_689042 = 2 * _689041;
int _689036;
_689036 = 2 * _689035;
int _689030;
_689030 = 2 * _689029;
int _693480;
_693480 = 2 * _693479;
int _693474;
_693474 = 2 * _693473;
int _693468;
_693468 = 2 * _693467;
int _695557;
_695557 = 2 * _695556;
int _695551;
_695551 = 2 * _695550;
int _695545;
_695545 = 2 * _695544;
int _694079;
_694079 = 2 * _694078;
int _694073;
_694073 = 2 * _694072;
int _694067;
_694067 = 2 * _694066;
int _689324;
_689324 = 2 * _689323;
int _689318;
_689318 = 2 * _689317;
int _689312;
_689312 = 2 * _689311;
int _693199;
_693199 = 2 * _693198;
int _693193;
_693193 = 2 * _693192;
int _693187;
_693187 = 2 * _693186;
int _690309;
_690309 = 2 * _690308;
int _690303;
_690303 = 2 * _690302;
int _690297;
_690297 = 2 * _690296;
int _689464;
_689464 = 2 * _689463;
int _689458;
_689458 = 2 * _689457;
int _689452;
_689452 = 2 * _689451;
int _694853;
_694853 = 2 * _694852;
int _694847;
_694847 = 2 * _694846;
int _694841;
_694841 = 2 * _694840;
int _691541;
_691541 = 2 * _691540;
int _691535;
_691535 = 2 * _691534;
int _691529;
_691529 = 2 * _691528;
int _689077;
_689077 = 2 * _689076;
int _689071;
_689071 = 2 * _689070;
int _689065;
_689065 = 2 * _689064;
int _691436;
_691436 = 2 * _691435;
int _691430;
_691430 = 2 * _691429;
int _691424;
_691424 = 2 * _691423;
int _694888;
_694888 = 2 * _694887;
int _694882;
_694882 = 2 * _694881;
int _694876;
_694876 = 2 * _694875;
int _693656;
_693656 = 2 * _693655;
int _693650;
_693650 = 2 * _693649;
int _693644;
_693644 = 2 * _693643;
int _690063;
_690063 = 2 * _690062;
int _690057;
_690057 = 2 * _690056;
int _690051;
_690051 = 2 * _690050;
int _694184;
_694184 = 2 * _694183;
int _694178;
_694178 = 2 * _694177;
int _694172;
_694172 = 2 * _694171;
float _698582;
_698582 = 1.000000e+00f - zf_698581;
int _691400;
_691400 = 2 * _691399;
int _691394;
_691394 = 2 * _691393;
int _691388;
_691388 = 2 * _691387;
int _689535;
_689535 = 2 * _689534;
int _689529;
_689529 = 2 * _689528;
int _689523;
_689523 = 2 * _689522;
int _691823;
_691823 = 2 * _691822;
int _691817;
_691817 = 2 * _691816;
int _691811;
_691811 = 2 * _691810;
int _695416;
_695416 = 2 * _695415;
int _695410;
_695410 = 2 * _695409;
int _695404;
_695404 = 2 * _695403;
int _689007;
_689007 = 2 * _689006;
int _689001;
_689001 = 2 * _689000;
int _688995;
_688995 = 2 * _688994;
int _691964;
_691964 = 2 * _691963;
int _691958;
_691958 = 2 * _691957;
int _691952;
_691952 = 2 * _691951;
int _689226;
_689226 = 2 + _689225;
int _689754;
_689754 = 2 + _689753;
int _689085;
_689085 = 2 + _689084;
int _690423;
_690423 = 2 + _690422;
int _690705;
_690705 = 2 + _690704;
int _691162;
_691162 = 2 + _691161;
int _692218;
_692218 = 2 + _692217;
int _689965;
_689965 = 2 + _689964;
int _690986;
_690986 = 2 + _690985;
int _691092;
_691092 = 2 + _691091;
int _690810;
_690810 = 2 + _690809;
int _690247;
_690247 = 2 + _690246;
int _692113;
_692113 = 2 + _692112;
int _689930;
_689930 = 2 + _689929;
int _691338;
_691338 = 2 + _691337;
int _689332;
_689332 = 2 + _689331;
int _690001;
_690001 = 2 + _690000;
int _689860;
_689860 = 2 + _689859;
int _691057;
_691057 = 2 + _691056;
int _689789;
_689789 = 2 + _689788;
int _691127;
_691127 = 2 + _691126;
int _688909;
_688909 = 2 + _688908;
int _689895;
_689895 = 2 + _689894;
int _689261;
_689261 = 2 + _689260;
int _691303;
_691303 = 2 + _691302;
int _690493;
_690493 = 2 + _690492;
int _691479;
_691479 = 2 + _691478;
int _691585;
_691585 = 2 + _691584;
int _689156;
_689156 = 2 + _689155;
int _691655;
_691655 = 2 + _691654;
int _691725;
_691725 = 2 + _691724;
int _690458;
_690458 = 2 + _690457;
int _692253;
_692253 = 2 + _692252;
int _692148;
_692148 = 2 + _692147;
int _691021;
_691021 = 2 + _691020;
int _689121;
_689121 = 2 + _689120;
int _689649;
_689649 = 2 + _689648;
int _692007;
_692007 = 2 + _692006;
int _689191;
_689191 = 2 + _689190;
int _689825;
_689825 = 2 + _689824;
int _691233;
_691233 = 2 + _691232;
int _691576;
_691576 = 2 * _691575;
int _691570;
_691570 = 2 * _691569;
int _691564;
_691564 = 2 * _691563;
int _694290;
_694290 = 2 * _694289;
int _694284;
_694284 = 2 * _694283;
int _694278;
_694278 = 2 * _694277;
int _691099;
_691099 = 2 + _691098;
int _689867;
_689867 = 2 + _689866;
int _690254;
_690254 = 2 + _690253;
int _689796;
_689796 = 2 + _689795;
int _689902;
_689902 = 2 + _689901;
int _690500;
_690500 = 2 + _690499;
int _689656;
_689656 = 2 + _689655;
int _691240;
_691240 = 2 + _691239;
int _691486;
_691486 = 2 + _691485;
int _689339;
_689339 = 2 + _689338;
int _689761;
_689761 = 2 + _689760;
int _689937;
_689937 = 2 + _689936;
int _689972;
_689972 = 2 + _689971;
int _691169;
_691169 = 2 + _691168;
int _691345;
_691345 = 2 + _691344;
int _690712;
_690712 = 2 + _690711;
int _688916;
_688916 = 2 + _688915;
int _691310;
_691310 = 2 + _691309;
int _689128;
_689128 = 2 + _689127;
int _691592;
_691592 = 2 + _691591;
int _691732;
_691732 = 2 + _691731;
int _690008;
_690008 = 2 + _690007;
int _689268;
_689268 = 2 + _689267;
int _690817;
_690817 = 2 + _690816;
int _690993;
_690993 = 2 + _690992;
int _691134;
_691134 = 2 + _691133;
int _689163;
_689163 = 2 + _689162;
int _692014;
_692014 = 2 + _692013;
int _692155;
_692155 = 2 + _692154;
int _690465;
_690465 = 2 + _690464;
int _692120;
_692120 = 2 + _692119;
int _689092;
_689092 = 2 + _689091;
int _692225;
_692225 = 2 + _692224;
int _692260;
_692260 = 2 + _692259;
int _691662;
_691662 = 2 + _691661;
int _691064;
_691064 = 2 + _691063;
int _690430;
_690430 = 2 + _690429;
int _691028;
_691028 = 2 + _691027;
int _689832;
_689832 = 2 + _689831;
int _689233;
_689233 = 2 + _689232;
int _689198;
_689198 = 2 + _689197;
int _694783;
_694783 = 2 * _694782;
int _694777;
_694777 = 2 * _694776;
int _694771;
_694771 = 2 * _694770;
int _694818;
_694818 = 2 * _694817;
int _694812;
_694812 = 2 * _694811;
int _694806;
_694806 = 2 * _694805;
int _689570;
_689570 = 2 * _689569;
int _689564;
_689564 = 2 * _689563;
int _689558;
_689558 = 2 * _689557;
int _693023;
_693023 = 2 * _693022;
int _693017;
_693017 = 2 * _693016;
int _693011;
_693011 = 2 * _693010;
int _688831;
_688831 = 2 * _688830;
int _688825;
_688825 = 2 * _688824;
int _688819;
_688819 = 2 * _688818;
int _694712;
_694712 = 2 * _694711;
int _694706;
_694706 = 2 * _694705;
int _694700;
_694700 = 2 * _694699;
int _693339;
_693339 = 2 * _693338;
int _693333;
_693333 = 2 * _693332;
int _693327;
_693327 = 2 * _693326;
int _695311;
_695311 = 2 * _695310;
int _695305;
_695305 = 2 * _695304;
int _695299;
_695299 = 2 * _695298;
int _690133;
_690133 = 2 * _690132;
int _690127;
_690127 = 2 * _690126;
int _690121;
_690121 = 2 * _690120;
int _689711;
_689711 = 2 * _689710;
int _689705;
_689705 = 2 * _689704;
int _689699;
_689699 = 2 * _689698;
int _690591;
_690591 = 2 * _690590;
int _690585;
_690585 = 2 * _690584;
int _690579;
_690579 = 2 * _690578;
int _690415;
_690415 = 2 * _690414;
int _690409;
_690409 = 2 * _690408;
int _690403;
_690403 = 2 * _690402;
int _695592;
_695592 = 2 * _695591;
int _695586;
_695586 = 2 * _695585;
int _695580;
_695580 = 2 * _695579;
int _690204;
_690204 = 2 * _690203;
int _690198;
_690198 = 2 * _690197;
int _690192;
_690192 = 2 * _690191;
float _698515;
_698515 = _698512 + _698514;
int _691611;
_691611 = 4 + _691598;
int _691605;
_691605 = 3 + _691598;
int _691599;
_691599 = 2 + _691598;
int _691681;
_691681 = 4 + _691668;
int _691675;
_691675 = 3 + _691668;
int _691669;
_691669 = 2 + _691668;
int _691938;
_691938 = 2 * _691937;
int _691945;
_691945 = 2 * _691944;
float _697361;
_697361 = 4.000000e+00f * _697360;
float _697165;
_697165 = _697163 + _697164;
float _695861;
_695861 = 6.000000e+00f * _695860;
float _698200;
_698200 = _698198 + _698199;
int _695767;
_695767 = 5 + _695754;
int _695761;
_695761 = 4 + _695754;
int _695755;
_695755 = 3 + _695754;
int _695741;
_695741 = 2 + _695740;
int _695748;
_695748 = 2 + _695747;
int _695732;
_695732 = 5 + _695719;
int _695726;
_695726 = 4 + _695719;
int _695720;
_695720 = 3 + _695719;
int _695706;
_695706 = 2 + _695705;
int _695713;
_695713 = 2 + _695712;
int _695697;
_695697 = 5 + _695684;
int _695691;
_695691 = 4 + _695684;
int _695685;
_695685 = 3 + _695684;
int _695671;
_695671 = 2 + _695670;
int _695678;
_695678 = 2 + _695677;
int _695802;
_695802 = 5 + _695789;
int _695796;
_695796 = 4 + _695789;
int _695790;
_695790 = 3 + _695789;
int _695783;
_695783 = 2 + _695782;
int _695776;
_695776 = 2 + _695775;
float _696534;
_696534 = _696532 + _696533;
float _696420;
_696420 = _696417 + _696419;
int _690389;
_690389 = 2 * _690388;
int _690396;
_690396 = 2 * _690395;
int _693937;
_693937 = 5 + _693924;
int _693931;
_693931 = 4 + _693924;
int _693925;
_693925 = 3 + _693924;
int _693911;
_693911 = 2 + _693910;
int _693918;
_693918 = 2 + _693917;
int _693902;
_693902 = 5 + _693889;
int _693896;
_693896 = 4 + _693889;
int _693890;
_693890 = 3 + _693889;
int _693876;
_693876 = 2 + _693875;
int _693883;
_693883 = 2 + _693882;
int _693972;
_693972 = 5 + _693959;
int _693966;
_693966 = 4 + _693959;
int _693960;
_693960 = 3 + _693959;
int _693946;
_693946 = 2 + _693945;
int _693953;
_693953 = 2 + _693952;
int _694042;
_694042 = 5 + _694029;
int _694036;
_694036 = 4 + _694029;
int _694030;
_694030 = 3 + _694029;
int _694016;
_694016 = 2 + _694015;
int _694023;
_694023 = 2 + _694022;
int _694007;
_694007 = 5 + _693994;
int _694001;
_694001 = 4 + _693994;
int _693995;
_693995 = 3 + _693994;
int _693981;
_693981 = 2 + _693980;
int _693988;
_693988 = 2 + _693987;
int _689921;
_689921 = 4 + _689908;
int _689915;
_689915 = 3 + _689908;
int _689909;
_689909 = 2 + _689908;
int _689886;
_689886 = 4 + _689873;
int _689880;
_689880 = 3 + _689873;
int _689874;
_689874 = 2 + _689873;
int _689851;
_689851 = 4 + _689838;
int _689845;
_689845 = 3 + _689838;
int _689839;
_689839 = 2 + _689838;
int _689991;
_689991 = 4 + _689978;
int _689985;
_689985 = 3 + _689978;
int _689979;
_689979 = 2 + _689978;
int _689956;
_689956 = 4 + _689943;
int _689950;
_689950 = 3 + _689943;
int _689944;
_689944 = 2 + _689943;
int _690142;
_690142 = 2 * _690141;
int _690149;
_690149 = 2 * _690148;
float _696767;
_696767 = _696765 + _696766;
int _690178;
_690178 = 2 * _690177;
int _690185;
_690185 = 2 * _690184;
float _696052;
_696052 = 4.000000e+00f * _696051;
float _696863;
_696863 = _696860 + _696862;
float _698322;
_698322 = _698320 + _698321;
float _696323;
_696323 = _696320 + _696322;
int _691797;
_691797 = 2 * _691796;
int _691804;
_691804 = 2 * _691803;
float _696972;
_696972 = _696970 + _696971;
float _696601;
_696601 = _696599 + _696600;
float _696461;
_696461 = _696458 + _696460;
int _689685;
_689685 = 2 * _689684;
int _689692;
_689692 = 2 * _689691;
int _692810;
_692810 = 5 + _692797;
int _692804;
_692804 = 4 + _692797;
int _692798;
_692798 = 3 + _692797;
int _692784;
_692784 = 2 + _692783;
int _692791;
_692791 = 2 + _692790;
int _692775;
_692775 = 5 + _692762;
int _692769;
_692769 = 4 + _692762;
int _692763;
_692763 = 3 + _692762;
int _692749;
_692749 = 2 + _692748;
int _692756;
_692756 = 2 + _692755;
int _692670;
_692670 = 5 + _692657;
int _692664;
_692664 = 4 + _692657;
int _692658;
_692658 = 3 + _692657;
int _692644;
_692644 = 2 + _692643;
int _692651;
_692651 = 2 + _692650;
int _692705;
_692705 = 5 + _692692;
int _692699;
_692699 = 4 + _692692;
int _692693;
_692693 = 3 + _692692;
int _692679;
_692679 = 2 + _692678;
int _692686;
_692686 = 2 + _692685;
float _697417;
_697417 = _697415 + _697416;
int _695134;
_695134 = 5 + _695121;
int _695128;
_695128 = 4 + _695121;
int _695122;
_695122 = 3 + _695121;
int _695108;
_695108 = 2 + _695107;
int _695115;
_695115 = 2 + _695114;
int _695239;
_695239 = 5 + _695226;
int _695233;
_695233 = 4 + _695226;
int _695227;
_695227 = 3 + _695226;
int _695213;
_695213 = 2 + _695212;
int _695220;
_695220 = 2 + _695219;
float _697800;
_697800 = _697798 + _697799;
int _691259;
_691259 = 4 + _691246;
int _691253;
_691253 = 3 + _691246;
int _691247;
_691247 = 2 + _691246;
int _691364;
_691364 = 4 + _691351;
int _691358;
_691358 = 3 + _691351;
int _691352;
_691352 = 2 + _691351;
int _691329;
_691329 = 4 + _691316;
int _691323;
_691323 = 3 + _691316;
int _691317;
_691317 = 2 + _691316;
float _698105;
_698105 = _698103 + _698104;
int _692529;
_692529 = 5 + _692516;
int _692523;
_692523 = 4 + _692516;
int _692517;
_692517 = 3 + _692516;
int _692503;
_692503 = 2 + _692502;
int _692510;
_692510 = 2 + _692509;
int _692599;
_692599 = 5 + _692586;
int _692593;
_692593 = 4 + _692586;
int _692587;
_692587 = 3 + _692586;
int _692573;
_692573 = 2 + _692572;
int _692580;
_692580 = 2 + _692579;
int _692634;
_692634 = 5 + _692621;
int _692628;
_692628 = 4 + _692621;
int _692622;
_692622 = 3 + _692621;
int _692608;
_692608 = 2 + _692607;
int _692615;
_692615 = 2 + _692614;
float _698283;
_698283 = _698281 + _698282;
int _693270;
_693270 = 1 + _693269;
int _693264;
_693264 = 1 + _693263;
int _693258;
_693258 = 1 + _693257;
float _695914;
_695914 = 4.000000e+00f * _695913;
float _698391;
_698391 = _698389 + _698390;
int _689298;
_689298 = 2 * _689297;
int _689305;
_689305 = 2 * _689304;
int _689368;
_689368 = 2 * _689367;
int _689375;
_689375 = 2 * _689374;
float _698021;
_698021 = _698019 + _698020;
float _696093;
_696093 = _696091 + _696092;
float _697784;
_697784 = _697781 + _697783;
float _697622;
_697622 = _697620 + _697621;
int _690952;
_690952 = 2 * _690951;
int _690959;
_690959 = 2 * _690958;
int _691120;
_691120 = 1 + _691119;
int _691114;
_691114 = 1 + _691113;
int _691108;
_691108 = 1 + _691107;
float _696616;
_696616 = 6.000000e+00f * _696615;
int _694748;
_694748 = 1 + _694747;
int _694742;
_694742 = 1 + _694741;
int _694736;
_694736 = 1 + _694735;
int _690283;
_690283 = 2 * _690282;
int _690290;
_690290 = 2 * _690289;
float _696011;
_696011 = 4.000000e+00f * _696010;
int _691515;
_691515 = 2 * _691514;
int _691522;
_691522 = 2 * _691521;
int _688946;
_688946 = 2 * _688945;
int _688953;
_688953 = 2 * _688952;
float _698118;
_698118 = 4.000000e+00f * _698117;
int _695523;
_695523 = 1 + _695522;
int _695517;
_695517 = 1 + _695516;
int _695511;
_695511 = 1 + _695510;
int _692043;
_692043 = 2 * _692042;
int _692050;
_692050 = 2 * _692049;
float _696562;
_696562 = _696560 + _696561;
int _690486;
_690486 = 1 + _690485;
int _690480;
_690480 = 1 + _690479;
int _690474;
_690474 = 1 + _690473;
int _690318;
_690318 = 2 * _690317;
int _690325;
_690325 = 2 * _690324;
int _694326;
_694326 = 1 + _694325;
int _694320;
_694320 = 1 + _694319;
int _694314;
_694314 = 1 + _694313;
float _696229;
_696229 = _696226 + _696228;
int _691269;
_691269 = 2 * _691268;
int _691276;
_691276 = 2 * _691275;
float _698048;
_698048 = _698046 + _698047;
float _696022;
_696022 = _696019 + _696021;
int _689438;
_689438 = 2 * _689437;
int _689445;
_689445 = 2 * _689444;
float _697455;
_697455 = _697452 + _697454;
int _691550;
_691550 = 2 * _691549;
int _691557;
_691557 = 2 * _691556;
float _696146;
_696146 = _696143 + _696145;
int _692078;
_692078 = 2 * _692077;
int _692085;
_692085 = 2 * _692084;
float _697527;
_697527 = 4.000000e+00f * _697526;
float _696187;
_696187 = _696184 + _696186;
int _695628;
_695628 = 1 + _695627;
int _695622;
_695622 = 1 + _695621;
int _695616;
_695616 = 1 + _695615;
int _691410;
_691410 = 2 * _691409;
int _691417;
_691417 = 2 * _691416;
float _698143;
_698143 = _698140 + _698142;
float _697068;
_697068 = _697065 + _697067;
int _693726;
_693726 = 5 + _693713;
int _693720;
_693720 = 4 + _693713;
int _693714;
_693714 = 3 + _693713;
int _693700;
_693700 = 2 + _693699;
int _693707;
_693707 = 2 + _693706;
int _693796;
_693796 = 5 + _693783;
int _693790;
_693790 = 4 + _693783;
int _693784;
_693784 = 3 + _693783;
int _693770;
_693770 = 2 + _693769;
int _693777;
_693777 = 2 + _693776;
int _693831;
_693831 = 5 + _693818;
int _693825;
_693825 = 4 + _693818;
int _693819;
_693819 = 3 + _693818;
int _693805;
_693805 = 2 + _693804;
int _693812;
_693812 = 2 + _693811;
int _693761;
_693761 = 5 + _693748;
int _693755;
_693755 = 4 + _693748;
int _693749;
_693749 = 3 + _693748;
int _693735;
_693735 = 2 + _693734;
int _693742;
_693742 = 2 + _693741;
int _693866;
_693866 = 5 + _693853;
int _693860;
_693860 = 4 + _693853;
int _693854;
_693854 = 3 + _693853;
int _693840;
_693840 = 2 + _693839;
int _693847;
_693847 = 2 + _693846;
float _695980;
_695980 = _695977 + _695979;
int _695028;
_695028 = 5 + _695015;
int _695022;
_695022 = 4 + _695015;
int _695016;
_695016 = 3 + _695015;
int _695002;
_695002 = 2 + _695001;
int _695009;
_695009 = 2 + _695008;
int _695098;
_695098 = 5 + _695085;
int _695092;
_695092 = 4 + _695085;
int _695086;
_695086 = 3 + _695085;
int _695072;
_695072 = 2 + _695071;
int _695079;
_695079 = 2 + _695078;
int _695063;
_695063 = 5 + _695050;
int _695057;
_695057 = 4 + _695050;
int _695051;
_695051 = 3 + _695050;
int _695037;
_695037 = 2 + _695036;
int _695044;
_695044 = 2 + _695043;
int _688981;
_688981 = 2 * _688980;
int _688988;
_688988 = 2 * _688987;
float _698433;
_698433 = _698431 + _698432;
float _696354;
_696354 = 4.000000e+00f * _696353;
float _695928;
_695928 = 6.000000e+00f * _695927;
float _696878;
_696878 = 4.000000e+00f * _696877;
float _696177;
_696177 = _696175 + _696176;
int _691691;
_691691 = 2 * _691690;
int _691698;
_691698 = 2 * _691697;
float _696491;
_696491 = _696489 + _696490;
int _689579;
_689579 = 2 * _689578;
int _689586;
_689586 = 2 * _689585;
int _695276;
_695276 = 1 + _695275;
int _695270;
_695270 = 1 + _695269;
int _695264;
_695264 = 1 + _695263;
int _689182;
_689182 = 4 + _689169;
int _689176;
_689176 = 3 + _689169;
int _689170;
_689170 = 2 + _689169;
int _689287;
_689287 = 4 + _689274;
int _689281;
_689281 = 3 + _689274;
int _689275;
_689275 = 2 + _689274;
int _689217;
_689217 = 4 + _689204;
int _689211;
_689211 = 3 + _689204;
int _689205;
_689205 = 2 + _689204;
int _689252;
_689252 = 4 + _689239;
int _689246;
_689246 = 3 + _689239;
int _689240;
_689240 = 2 + _689239;
int _689147;
_689147 = 4 + _689134;
int _689141;
_689141 = 3 + _689134;
int _689135;
_689135 = 2 + _689134;
float _697191;
_697191 = _697188 + _697190;
int _689113;
_689113 = 1 + _689112;
int _689107;
_689107 = 1 + _689106;
int _689101;
_689101 = 1 + _689100;
int _690733;
_690733 = 1 + _690732;
int _690727;
_690727 = 1 + _690726;
int _690721;
_690721 = 1 + _690720;
float _698529;
_698529 = _698527 + _698528;
float _696685;
_696685 = 6.000000e+00f * _696684;
float _698555;
_698555 = _698552 + _698554;
float _697430;
_697430 = 4.000000e+00f * _697429;
float _697758;
_697758 = _697755 + _697757;
float _698544;
_698544 = 6.000000e+00f * _698543;
float _697179;
_697179 = _697177 + _697178;
float _698403;
_698403 = _698400 + _698402;
float _695953;
_695953 = _695950 + _695952;
int _691753;
_691753 = 1 + _691752;
int _691747;
_691747 = 1 + _691746;
int _691741;
_691741 = 1 + _691740;
int _692458;
_692458 = 5 + _692445;
int _692452;
_692452 = 4 + _692445;
int _692446;
_692446 = 3 + _692445;
int _692432;
_692432 = 2 + _692431;
int _692439;
_692439 = 2 + _692438;
int _692423;
_692423 = 5 + _692410;
int _692417;
_692417 = 4 + _692410;
int _692411;
_692411 = 3 + _692410;
int _692397;
_692397 = 2 + _692396;
int _692404;
_692404 = 2 + _692403;
int _692318;
_692318 = 5 + _692305;
int _692312;
_692312 = 4 + _692305;
int _692306;
_692306 = 3 + _692305;
int _692291;
_692291 = 2 + _692290;
int _692299;
_692299 = 2 + _692298;
int _692388;
_692388 = 5 + _692375;
int _692382;
_692382 = 4 + _692375;
int _692376;
_692376 = 3 + _692375;
int _692362;
_692362 = 2 + _692361;
int _692369;
_692369 = 2 + _692368;
int _692353;
_692353 = 5 + _692340;
int _692347;
_692347 = 4 + _692340;
int _692341;
_692341 = 3 + _692340;
int _692327;
_692327 = 2 + _692326;
int _692334;
_692334 = 2 + _692333;
int _689509;
_689509 = 2 * _689508;
int _689516;
_689516 = 2 * _689515;
float _697303;
_697303 = _697300 + _697302;
float _698214;
_698214 = _698212 + _698213;
float _697538;
_697538 = _697535 + _697537;
float _695875;
_695875 = 4.000000e+00f * _695874;
int _689782;
_689782 = 1 + _689781;
int _689776;
_689776 = 1 + _689775;
int _689770;
_689770 = 1 + _689769;
float _698088;
_698088 = _698085 + _698087;
float _697991;
_697991 = _697988 + _697990;
float _697498;
_697498 = _697496 + _697497;
float _698257;
_698257 = _698243 + _698256;
float _697291;
_697291 = _697289 + _697290;
int _691155;
_691155 = 1 + _691154;
int _691149;
_691149 = 1 + _691148;
int _691143;
_691143 = 1 + _691142;
float _698472;
_698472 = _698469 + _698471;
int _691374;
_691374 = 2 * _691373;
int _691381;
_691381 = 2 * _691380;
int _691762;
_691762 = 2 * _691761;
int _691769;
_691769 = 2 * _691768;
float _696242;
_696242 = _696239 + _696241;
float _696282;
_696282 = _696279 + _696281;
int _689677;
_689677 = 1 + _689676;
int _689671;
_689671 = 1 + _689670;
int _689665;
_689665 = 1 + _689664;
float _696367;
_696367 = _696365 + _696366;
int _693376;
_693376 = 1 + _693375;
int _693370;
_693370 = 1 + _693369;
int _693364;
_693364 = 1 + _693363;
float _697513;
_697513 = 6.000000e+00f * _697512;
float _696451;
_696451 = _696449 + _696450;
float _697927;
_697927 = 6.000000e+00f * _697926;
float _697225;
_697225 = 4.000000e+00f * _697224;
int _692244;
_692244 = 4 + _692231;
int _692238;
_692238 = 3 + _692231;
int _692232;
_692232 = 2 + _692231;
int _692279;
_692279 = 4 + _692266;
int _692273;
_692273 = 3 + _692266;
int _692267;
_692267 = 2 + _692266;
int _692174;
_692174 = 4 + _692161;
int _692168;
_692168 = 3 + _692161;
int _692162;
_692162 = 2 + _692161;
int _692139;
_692139 = 4 + _692126;
int _692133;
_692133 = 3 + _692126;
int _692127;
_692127 = 2 + _692126;
float _698350;
_698350 = _698348 + _698349;
int _691973;
_691973 = 2 * _691972;
int _691980;
_691980 = 2 * _691979;
float _696135;
_696135 = 6.000000e+00f * _696134;
float _697317;
_697317 = _697314 + _697316;
int _690521;
_690521 = 1 + _690520;
int _690515;
_690515 = 1 + _690514;
int _690509;
_690509 = 1 + _690508;
float _698063;
_698063 = 6.000000e+00f * _698062;
int _694572;
_694572 = 1 + _694571;
int _694566;
_694566 = 1 + _694565;
int _694560;
_694560 = 1 + _694559;
float _698417;
_698417 = _698414 + _698416;
float _696257;
_696257 = 4.000000e+00f * _696256;
int _689817;
_689817 = 1 + _689816;
int _689811;
_689811 = 1 + _689810;
int _689805;
_689805 = 1 + _689804;
int _694220;
_694220 = 1 + _694219;
int _694214;
_694214 = 1 + _694213;
int _694208;
_694208 = 1 + _694207;
float _697082;
_697082 = _697080 + _697081;
float _697484;
_697484 = _697481 + _697483;
float _696549;
_696549 = 6.000000e+00f * _696548;
int _689544;
_689544 = 2 * _689543;
int _689551;
_689551 = 2 * _689550;
float _697553;
_697553 = _697550 + _697552;
float _696406;
_696406 = _696403 + _696405;
float _696834;
_696834 = _696831 + _696833;
float _696160;
_696160 = _696157 + _696159;
float _696587;
_696587 = _696584 + _696586;
int _692184;
_692184 = 2 * _692183;
int _692191;
_692191 = 2 * _692190;
float _698186;
_698186 = _698184 + _698185;
float _697977;
_697977 = _697974 + _697976;
int _690037;
_690037 = 2 * _690036;
int _690044;
_690044 = 2 * _690043;
float _696108;
_696108 = _696106 + _696107;
float _698007;
_698007 = _698005 + _698006;
float _696670;
_696670 = _696668 + _696669;
int _689720;
_689720 = 2 * _689719;
int _689727;
_689727 = 2 * _689726;
int _690917;
_690917 = 2 * _690916;
int _690924;
_690924 = 2 * _690923;
float _697913;
_697913 = 4.000000e+00f * _697912;
int _691507;
_691507 = 1 + _691506;
int _691501;
_691501 = 1 + _691500;
int _691495;
_691495 = 1 + _691494;
float _697266;
_697266 = _697264 + _697265;
float _696984;
_696984 = _696981 + _696983;
int _694537;
_694537 = 1 + _694536;
int _694531;
_694531 = 1 + _694530;
int _694525;
_694525 = 1 + _694524;
float _698486;
_698486 = _698483 + _698485;
float _697853;
_697853 = _697850 + _697852;
float _697139;
_697139 = _697137 + _697138;
float _696643;
_696643 = _696641 + _696642;
float _696698;
_696698 = _696696 + _696697;
int _689474;
_689474 = 2 * _689473;
int _689481;
_689481 = 2 * _689480;
float _698295;
_698295 = _698292 + _698294;
int _689360;
_689360 = 1 + _689359;
int _689354;
_689354 = 1 + _689353;
int _689348;
_689348 = 1 + _689347;
float _698074;
_698074 = _698071 + _698073;
float _697014;
_697014 = 4.000000e+00f * _697013;
int _690451;
_690451 = 1 + _690450;
int _690445;
_690445 = 1 + _690444;
int _690439;
_690439 = 1 + _690438;
float _696903;
_696903 = _696900 + _696902;
int _689614;
_689614 = 2 * _689613;
int _689621;
_689621 = 2 * _689620;
float _698379;
_698379 = _698377 + _698378;
int _691621;
_691621 = 2 * _691620;
int _691628;
_691628 = 2 * _691627;
float _697967;
_697967 = _697965 + _697966;
float _696945;
_696945 = 4.000000e+00f * _696944;
int _690530;
_690530 = 2 * _690529;
int _690537;
_690537 = 2 * _690536;
int _695488;
_695488 = 1 + _695487;
int _695482;
_695482 = 1 + _695481;
int _695476;
_695476 = 1 + _695475;
float _696271;
_696271 = 6.000000e+00f * _696270;
int _690354;
_690354 = 2 * _690353;
int _690361;
_690361 = 2 * _690360;
float _697375;
_697375 = 6.000000e+00f * _697374;
int _691198;
_691198 = 2 * _691197;
int _691205;
_691205 = 2 * _691204;
int _689403;
_689403 = 2 * _689402;
int _689410;
_689410 = 2 * _689409;
int _690072;
_690072 = 2 * _690071;
int _690079;
_690079 = 2 * _690078;
int _690107;
_690107 = 2 * _690106;
int _690114;
_690114 = 2 * _690113;
float _696630;
_696630 = 4.000000e+00f * _696629;
int _689051;
_689051 = 2 * _689050;
int _689058;
_689058 = 2 * _689057;
int _689016;
_689016 = 2 * _689015;
int _689023;
_689023 = 2 * _689022;
float _696080;
_696080 = 4.000000e+00f * _696079;
int _690882;
_690882 = 2 * _690881;
int _690889;
_690889 = 2 * _690888;
int _693411;
_693411 = 1 + _693410;
int _693405;
_693405 = 1 + _693404;
int _693399;
_693399 = 1 + _693398;
float _697443;
_697443 = _697441 + _697442;
int _692918;
_692918 = 1 + _692917;
int _692912;
_692912 = 1 + _692911;
int _692906;
_692906 = 1 + _692905;
float _697362;
_697362 = _697348 + _697361;
int _691085;
_691085 = 1 + _691084;
int _691079;
_691079 = 1 + _691078;
int _691073;
_691073 = 1 + _691072;
float _696477;
_696477 = _696475 + _696476;
float _697042;
_697042 = 4.000000e+00f * _697041;
float _697954;
_697954 = _697952 + _697953;
float _697691;
_697691 = _697689 + _697690;
int _690565;
_690565 = 2 * _690564;
int _690572;
_690572 = 2 * _690571;
int _690635;
_690635 = 2 * _690634;
int _690642;
_690642 = 2 * _690641;
int _690600;
_690600 = 2 * _690599;
int _690607;
_690607 = 2 * _690606;
int _690670;
_690670 = 2 * _690669;
int _690677;
_690677 = 2 * _690676;
int _691445;
_691445 = 2 * _691444;
int _691452;
_691452 = 2 * _691451;
int _694467;
_694467 = 1 + _694466;
int _694461;
_694461 = 1 + _694460;
int _694455;
_694455 = 1 + _694454;
float _697870;
_697870 = 4.000000e+00f * _697869;
float _697773;
_697773 = 4.000000e+00f * _697772;
float _697596;
_697596 = 4.000000e+00f * _697595;
float _697634;
_697634 = _697632 + _697633;
int _692988;
_692988 = 1 + _692987;
int _692982;
_692982 = 1 + _692981;
int _692976;
_692976 = 1 + _692975;
int _690846;
_690846 = 2 * _690845;
int _690853;
_690853 = 2 * _690852;
int _690741;
_690741 = 2 * _690740;
int _690748;
_690748 = 2 * _690747;
int _690776;
_690776 = 2 * _690775;
int _690783;
_690783 = 2 * _690782;
float _696066;
_696066 = 6.000000e+00f * _696065;
int _693235;
_693235 = 1 + _693234;
int _693229;
_693229 = 1 + _693228;
int _693223;
_693223 = 1 + _693222;
int _691014;
_691014 = 1 + _691013;
int _691008;
_691008 = 1 + _691007;
int _691002;
_691002 = 1 + _691001;
float _696122;
_696122 = _696108 + _696121;
float _696740;
_696740 = 4.000000e+00f * _696739;
int _690838;
_690838 = 1 + _690837;
int _690832;
_690832 = 1 + _690831;
int _690826;
_690826 = 1 + _690825;
float _697028;
_697028 = 6.000000e+00f * _697027;
float _697252;
_697252 = _697250 + _697251;
int _688840;
_688840 = 2 * _688839;
int _688847;
_688847 = 2 * _688846;
int _688769;
_688769 = 2 * _688768;
int _688777;
_688777 = 2 * _688776;
int _688875;
_688875 = 2 * _688874;
int _688882;
_688882 = 2 * _688881;
int _688805;
_688805 = 2 * _688804;
int _688812;
_688812 = 2 * _688811;
float _696809;
_696809 = 4.000000e+00f * _696808;
int _690213;
_690213 = 2 * _690212;
int _690220;
_690220 = 2 * _690219;
int _691190;
_691190 = 1 + _691189;
int _691184;
_691184 = 1 + _691183;
int _691178;
_691178 = 1 + _691177;
int _691049;
_691049 = 1 + _691048;
int _691043;
_691043 = 1 + _691042;
int _691037;
_691037 = 1 + _691036;
float _697704;
_697704 = 4.000000e+00f * _697703;
int _690275;
_690275 = 1 + _690274;
int _690269;
_690269 = 1 + _690268;
int _690263;
_690263 = 1 + _690262;
int _691902;
_691902 = 2 * _691901;
int _691909;
_691909 = 2 * _691908;
int _691867;
_691867 = 2 * _691866;
int _691874;
_691874 = 2 * _691873;
int _691832;
_691832 = 2 * _691831;
int _691839;
_691839 = 2 * _691838;
float _697731;
_697731 = _697729 + _697730;
int _694643;
_694643 = 1 + _694642;
int _694637;
_694637 = 1 + _694636;
int _694631;
_694631 = 1 + _694630;
float _697914;
_697914 = _697900 + _697913;
float _695996;
_695996 = _695994 + _695995;
float _697389;
_697389 = 4.000000e+00f * _697388;
int _693552;
_693552 = 1 + _693551;
int _693546;
_693546 = 1 + _693545;
int _693540;
_693540 = 1 + _693539;
float _697151;
_697151 = _697149 + _697150;
float _697717;
_697717 = _697715 + _697716;
float _698131;
_698131 = _698129 + _698130;
float _695847;
_695847 = 4.000000e+00f * _695846;
float _696395;
_696395 = 4.000000e+00f * _696394;
float _698448;
_698448 = _698446 + _698447;
int _688937;
_688937 = 1 + _688936;
int _688931;
_688931 = 1 + _688930;
int _688925;
_688925 = 1 + _688924;
int _694115;
_694115 = 1 + _694114;
int _694109;
_694109 = 1 + _694108;
int _694103;
_694103 = 1 + _694102;
float _696712;
_696712 = _696710 + _696711;
int _692035;
_692035 = 1 + _692034;
int _692029;
_692029 = 1 + _692028;
int _692023;
_692023 = 1 + _692022;
int _693094;
_693094 = 1 + _693093;
int _693088;
_693088 = 1 + _693087;
int _693082;
_693082 = 1 + _693081;
int _692883;
_692883 = 1 + _692882;
int _692877;
_692877 = 1 + _692876;
int _692871;
_692871 = 1 + _692870;
int _694256;
_694256 = 1 + _694255;
int _694250;
_694250 = 1 + _694249;
int _694244;
_694244 = 1 + _694243;
int _691472;
_691472 = 1 + _691471;
int _691466;
_691466 = 1 + _691465;
int _691460;
_691460 = 1 + _691459;
int _692953;
_692953 = 1 + _692952;
int _692947;
_692947 = 1 + _692946;
int _692941;
_692941 = 1 + _692940;
int _690909;
_690909 = 1 + _690908;
int _690903;
_690903 = 1 + _690902;
int _690897;
_690897 = 1 + _690896;
int _691225;
_691225 = 1 + _691224;
int _691219;
_691219 = 1 + _691218;
int _691213;
_691213 = 1 + _691212;
int _688902;
_688902 = 1 + _688901;
int _688896;
_688896 = 1 + _688895;
int _688890;
_688890 = 1 + _688889;
int _690029;
_690029 = 1 + _690028;
int _690023;
_690023 = 1 + _690022;
int _690017;
_690017 = 1 + _690016;
int _693059;
_693059 = 1 + _693058;
int _693053;
_693053 = 1 + _693052;
int _693047;
_693047 = 1 + _693046;
int _692070;
_692070 = 1 + _692069;
int _692064;
_692064 = 1 + _692063;
int _692058;
_692058 = 1 + _692057;
int _694924;
_694924 = 1 + _694923;
int _694918;
_694918 = 1 + _694917;
int _694912;
_694912 = 1 + _694911;
int _693129;
_693129 = 1 + _693128;
int _693123;
_693123 = 1 + _693122;
int _693117;
_693117 = 1 + _693116;
int _695347;
_695347 = 1 + _695346;
int _695341;
_695341 = 1 + _695340;
int _695335;
_695335 = 1 + _695334;
int _692000;
_692000 = 1 + _691999;
int _691994;
_691994 = 1 + _691993;
int _691988;
_691988 = 1 + _691987;
int _688867;
_688867 = 1 + _688866;
int _688861;
_688861 = 1 + _688860;
int _688855;
_688855 = 1 + _688854;
int _690381;
_690381 = 1 + _690380;
int _690375;
_690375 = 1 + _690374;
int _690369;
_690369 = 1 + _690368;
int _694678;
_694678 = 1 + _694677;
int _694672;
_694672 = 1 + _694671;
int _694666;
_694666 = 1 + _694665;
int _693516;
_693516 = 1 + _693515;
int _693510;
_693510 = 1 + _693509;
int _693504;
_693504 = 1 + _693503;
int _693164;
_693164 = 1 + _693163;
int _693158;
_693158 = 1 + _693157;
int _693152;
_693152 = 1 + _693151;
int _695206;
_695206 = 1 + _695205;
int _695200;
_695200 = 1 + _695199;
int _695194;
_695194 = 1 + _695193;
int _690768;
_690768 = 1 + _690767;
int _690762;
_690762 = 1 + _690761;
int _690756;
_690756 = 1 + _690755;
int _688973;
_688973 = 1 + _688972;
int _688967;
_688967 = 1 + _688966;
int _688961;
_688961 = 1 + _688960;
int _688797;
_688797 = 1 + _688796;
int _688791;
_688791 = 1 + _688790;
int _688785;
_688785 = 1 + _688784;
int _690873;
_690873 = 1 + _690872;
int _690867;
_690867 = 1 + _690866;
int _690861;
_690861 = 1 + _690860;
int _689606;
_689606 = 1 + _689605;
int _689600;
_689600 = 1 + _689599;
int _689594;
_689594 = 1 + _689593;
int _693692;
_693692 = 1 + _693691;
int _693686;
_693686 = 1 + _693685;
int _693680;
_693680 = 1 + _693679;
int _693622;
_693622 = 1 + _693621;
int _693616;
_693616 = 1 + _693615;
int _693610;
_693610 = 1 + _693609;
int _692496;
_692496 = 1 + _692495;
int _692490;
_692490 = 1 + _692489;
int _692484;
_692484 = 1 + _692483;
int _693305;
_693305 = 1 + _693304;
int _693299;
_693299 = 1 + _693298;
int _693293;
_693293 = 1 + _693292;
int _692848;
_692848 = 1 + _692847;
int _692842;
_692842 = 1 + _692841;
int _692836;
_692836 = 1 + _692835;
int _692566;
_692566 = 1 + _692565;
int _692560;
_692560 = 1 + _692559;
int _692554;
_692554 = 1 + _692553;
int _694361;
_694361 = 1 + _694360;
int _694355;
_694355 = 1 + _694354;
int _694349;
_694349 = 1 + _694348;
int _693587;
_693587 = 1 + _693586;
int _693581;
_693581 = 1 + _693580;
int _693575;
_693575 = 1 + _693574;
int _690557;
_690557 = 1 + _690556;
int _690551;
_690551 = 1 + _690550;
int _690545;
_690545 = 1 + _690544;
int _691296;
_691296 = 1 + _691295;
int _691290;
_691290 = 1 + _691289;
int _691284;
_691284 = 1 + _691283;
int _694995;
_694995 = 1 + _694994;
int _694989;
_694989 = 1 + _694988;
int _694983;
_694983 = 1 + _694982;
int _694396;
_694396 = 1 + _694395;
int _694390;
_694390 = 1 + _694389;
int _694384;
_694384 = 1 + _694383;
int _695664;
_695664 = 1 + _695663;
int _695658;
_695658 = 1 + _695657;
int _695652;
_695652 = 1 + _695651;
int _694608;
_694608 = 1 + _694607;
int _694602;
_694602 = 1 + _694601;
int _694596;
_694596 = 1 + _694595;
int _691859;
_691859 = 1 + _691858;
int _691853;
_691853 = 1 + _691852;
int _691847;
_691847 = 1 + _691846;
int _691894;
_691894 = 1 + _691893;
int _691888;
_691888 = 1 + _691887;
int _691882;
_691882 = 1 + _691881;
int _690697;
_690697 = 1 + _690696;
int _690691;
_690691 = 1 + _690690;
int _690685;
_690685 = 1 + _690684;
int _695643;
_695643 = 2 + _695642;
int _692545;
_692545 = 2 + _692544;
int _694516;
_694516 = 2 + _694515;
int _693495;
_693495 = 2 + _693494;
int _694340;
_694340 = 2 + _694339;
int _694059;
_694059 = 2 + _694058;
int _694657;
_694657 = 2 + _694656;
int _694481;
_694481 = 2 + _694480;
int _694763;
_694763 = 2 + _694762;
int _695467;
_695467 = 2 + _695466;
int _695396;
_695396 = 2 + _695395;
int _693179;
_693179 = 2 + _693178;
int _693460;
_693460 = 2 + _693459;
int _694305;
_694305 = 2 + _694304;
int _695255;
_695255 = 2 + _695254;
int _694551;
_694551 = 2 + _694550;
int _693249;
_693249 = 2 + _693248;
int _693671;
_693671 = 2 + _693670;
int _692862;
_692862 = 2 + _692861;
int _693601;
_693601 = 2 + _693600;
int _694868;
_694868 = 2 + _694867;
int _694622;
_694622 = 2 + _694621;
int _693108;
_693108 = 2 + _693107;
int _693214;
_693214 = 2 + _693213;
int _693636;
_693636 = 2 + _693635;
int _694164;
_694164 = 2 + _694163;
int _695431;
_695431 = 2 + _695430;
int _693143;
_693143 = 2 + _693142;
int _695150;
_695150 = 2 + _695149;
int _695326;
_695326 = 2 + _695325;
int _693003;
_693003 = 2 + _693002;
int _695537;
_695537 = 2 + _695536;
int _693531;
_693531 = 2 + _693530;
int _692827;
_692827 = 2 + _692826;
int _694129;
_694129 = 2 + _694128;
int _694235;
_694235 = 2 + _694234;
int _693390;
_693390 = 2 + _693389;
int _694939;
_694939 = 2 + _694938;
int _692932;
_692932 = 2 + _692931;
int _694375;
_694375 = 2 + _694374;
int _693038;
_693038 = 2 + _693037;
int _695361;
_695361 = 2 + _695360;
int _693425;
_693425 = 2 + _693424;
int _695185;
_695185 = 2 + _695184;
int _694833;
_694833 = 2 + _694832;
int _694411;
_694411 = 2 + _694410;
int _694798;
_694798 = 2 + _694797;
int _695572;
_695572 = 2 + _695571;
int _694446;
_694446 = 2 + _694445;
int _692967;
_692967 = 2 + _692966;
int _694692;
_694692 = 2 + _694691;
int _692475;
_692475 = 2 + _692474;
int _693284;
_693284 = 2 + _693283;
int _692721;
_692721 = 2 + _692720;
int _693355;
_693355 = 2 + _693354;
int _693319;
_693319 = 2 + _693318;
int _694199;
_694199 = 2 + _694198;
int _695291;
_695291 = 2 + _695290;
int _693566;
_693566 = 2 + _693565;
int _694974;
_694974 = 2 + _694973;
int _694727;
_694727 = 2 + _694726;
int _693073;
_693073 = 2 + _693072;
int _695502;
_695502 = 2 + _695501;
int _692897;
_692897 = 2 + _692896;
int _694587;
_694587 = 2 + _694586;
int _694094;
_694094 = 2 + _694093;
int _694903;
_694903 = 2 + _694902;
int _695607;
_695607 = 2 + _695606;
int _694270;
_694270 = 2 + _694269;
int _693277;
_693277 = 2 + _693276;
int _694157;
_694157 = 2 + _694156;
int _695354;
_695354 = 2 + _695353;
int _694967;
_694967 = 2 + _694966;
int _694791;
_694791 = 2 + _694790;
int _694756;
_694756 = 2 + _694755;
int _694228;
_694228 = 2 + _694227;
int _695565;
_695565 = 2 + _695564;
int _693207;
_693207 = 2 + _693206;
int _693101;
_693101 = 2 + _693100;
int _694544;
_694544 = 2 + _694543;
int _694615;
_694615 = 2 + _694614;
int _694685;
_694685 = 2 + _694684;
int _692996;
_692996 = 2 + _692995;
int _692960;
_692960 = 2 + _692959;
int _692925;
_692925 = 2 + _692924;
int _693418;
_693418 = 2 + _693417;
int _693488;
_693488 = 2 + _693487;
int _693172;
_693172 = 2 + _693171;
int _695424;
_695424 = 2 + _695423;
int _692714;
_692714 = 2 + _692713;
int _695178;
_695178 = 2 + _695177;
int _694192;
_694192 = 2 + _694191;
int _692890;
_692890 = 2 + _692889;
int _695389;
_695389 = 2 + _695388;
int _694052;
_694052 = 2 + _694051;
int _693312;
_693312 = 2 + _693311;
int _695319;
_695319 = 2 + _695318;
int _694580;
_694580 = 2 + _694579;
int _693066;
_693066 = 2 + _693065;
int _693348;
_693348 = 2 + _693347;
int _694263;
_694263 = 2 + _694262;
int _692820;
_692820 = 2 + _692819;
int _693136;
_693136 = 2 + _693135;
int _695636;
_695636 = 2 + _695635;
int _694509;
_694509 = 2 + _694508;
int _692468;
_692468 = 2 + _692467;
int _694826;
_694826 = 2 + _694825;
int _695284;
_695284 = 2 + _695283;
int _694298;
_694298 = 2 + _694297;
int _693524;
_693524 = 2 + _693523;
int _694896;
_694896 = 2 + _694895;
int _694122;
_694122 = 2 + _694121;
int _695143;
_695143 = 2 + _695142;
int _693594;
_693594 = 2 + _693593;
int _693242;
_693242 = 2 + _693241;
int _694474;
_694474 = 2 + _694473;
int _694720;
_694720 = 2 + _694719;
int _695460;
_695460 = 2 + _695459;
int _693031;
_693031 = 2 + _693030;
int _695248;
_695248 = 2 + _695247;
int _694650;
_694650 = 2 + _694649;
int _694333;
_694333 = 2 + _694332;
int _693453;
_693453 = 2 + _693452;
int _695600;
_695600 = 2 + _695599;
int _693629;
_693629 = 2 + _693628;
int _692855;
_692855 = 2 + _692854;
int _694439;
_694439 = 2 + _694438;
int _693664;
_693664 = 2 + _693663;
int _693559;
_693559 = 2 + _693558;
int _694087;
_694087 = 2 + _694086;
int _693383;
_693383 = 2 + _693382;
int _692538;
_692538 = 2 + _692537;
int _695530;
_695530 = 2 + _695529;
int _695495;
_695495 = 2 + _695494;
int _694932;
_694932 = 2 + _694931;
int _694368;
_694368 = 2 + _694367;
int _694404;
_694404 = 2 + _694403;
int _694861;
_694861 = 2 + _694860;
int _694432;
_694432 = 1 + _694431;
int _694426;
_694426 = 1 + _694425;
int _694420;
_694420 = 1 + _694419;
int _690345;
_690345 = 1 + _690344;
int _690339;
_690339 = 1 + _690338;
int _690333;
_690333 = 1 + _690332;
int _690803;
_690803 = 1 + _690802;
int _690797;
_690797 = 1 + _690796;
int _690791;
_690791 = 1 + _690790;
int _692211;
_692211 = 1 + _692210;
int _692205;
_692205 = 1 + _692204;
int _692199;
_692199 = 1 + _692198;
int _689747;
_689747 = 1 + _689746;
int _689741;
_689741 = 1 + _689740;
int _689735;
_689735 = 1 + _689734;
int _690944;
_690944 = 1 + _690943;
int _690938;
_690938 = 1 + _690937;
int _690932;
_690932 = 1 + _690931;
int _690169;
_690169 = 1 + _690168;
int _690163;
_690163 = 1 + _690162;
int _690157;
_690157 = 1 + _690156;
int _691718;
_691718 = 1 + _691717;
int _691712;
_691712 = 1 + _691711;
int _691706;
_691706 = 1 + _691705;
int _691929;
_691929 = 1 + _691928;
int _691923;
_691923 = 1 + _691922;
int _691917;
_691917 = 1 + _691916;
int _695452;
_695452 = 1 + _695451;
int _695446;
_695446 = 1 + _695445;
int _695440;
_695440 = 1 + _695439;
int _690979;
_690979 = 1 + _690978;
int _690973;
_690973 = 1 + _690972;
int _690967;
_690967 = 1 + _690966;
int _689395;
_689395 = 1 + _689394;
int _689389;
_689389 = 1 + _689388;
int _689383;
_689383 = 1 + _689382;
int _692742;
_692742 = 1 + _692741;
int _692736;
_692736 = 1 + _692735;
int _692730;
_692730 = 1 + _692729;
int _690099;
_690099 = 1 + _690098;
int _690093;
_690093 = 1 + _690092;
int _690087;
_690087 = 1 + _690086;
int _690240;
_690240 = 1 + _690239;
int _690234;
_690234 = 1 + _690233;
int _690228;
_690228 = 1 + _690227;
int _690627;
_690627 = 1 + _690626;
int _690621;
_690621 = 1 + _690620;
int _690615;
_690615 = 1 + _690614;
int _689501;
_689501 = 1 + _689500;
int _689495;
_689495 = 1 + _689494;
int _689489;
_689489 = 1 + _689488;
int _691648;
_691648 = 1 + _691647;
int _691642;
_691642 = 1 + _691641;
int _691636;
_691636 = 1 + _691635;
int _692105;
_692105 = 1 + _692104;
int _692099;
_692099 = 1 + _692098;
int _692093;
_692093 = 1 + _692092;
int _690662;
_690662 = 1 + _690661;
int _690656;
_690656 = 1 + _690655;
int _690650;
_690650 = 1 + _690649;
int _693446;
_693446 = 1 + _693445;
int _693440;
_693440 = 1 + _693439;
int _693434;
_693434 = 1 + _693433;
int _695171;
_695171 = 1 + _695170;
int _695165;
_695165 = 1 + _695164;
int _695159;
_695159 = 1 + _695158;
int _694960;
_694960 = 1 + _694959;
int _694954;
_694954 = 1 + _694953;
int _694948;
_694948 = 1 + _694947;
int _694150;
_694150 = 1 + _694149;
int _694144;
_694144 = 1 + _694143;
int _694138;
_694138 = 1 + _694137;
int _689430;
_689430 = 1 + _689429;
int _689424;
_689424 = 1 + _689423;
int _689418;
_689418 = 1 + _689417;
int _689641;
_689641 = 1 + _689640;
int _689635;
_689635 = 1 + _689634;
int _689629;
_689629 = 1 + _689628;
int _691789;
_691789 = 1 + _691788;
int _691783;
_691783 = 1 + _691782;
int _691777;
_691777 = 1 + _691776;
int _695382;
_695382 = 1 + _695381;
int _695376;
_695376 = 1 + _695375;
int _695370;
_695370 = 1 + _695369;
int _694502;
_694502 = 1 + _694501;
int _694496;
_694496 = 1 + _694495;
int _694490;
_694490 = 1 + _694489;
int _689043;
_689043 = 1 + _689042;
int _689037;
_689037 = 1 + _689036;
int _689031;
_689031 = 1 + _689030;
int _693481;
_693481 = 1 + _693480;
int _693475;
_693475 = 1 + _693474;
int _693469;
_693469 = 1 + _693468;
int _695558;
_695558 = 1 + _695557;
int _695552;
_695552 = 1 + _695551;
int _695546;
_695546 = 1 + _695545;
int _694080;
_694080 = 1 + _694079;
int _694074;
_694074 = 1 + _694073;
int _694068;
_694068 = 1 + _694067;
int _689325;
_689325 = 1 + _689324;
int _689319;
_689319 = 1 + _689318;
int _689313;
_689313 = 1 + _689312;
int _693200;
_693200 = 1 + _693199;
int _693194;
_693194 = 1 + _693193;
int _693188;
_693188 = 1 + _693187;
int _690310;
_690310 = 1 + _690309;
int _690304;
_690304 = 1 + _690303;
int _690298;
_690298 = 1 + _690297;
int _689465;
_689465 = 1 + _689464;
int _689459;
_689459 = 1 + _689458;
int _689453;
_689453 = 1 + _689452;
int _694854;
_694854 = 1 + _694853;
int _694848;
_694848 = 1 + _694847;
int _694842;
_694842 = 1 + _694841;
int _691542;
_691542 = 1 + _691541;
int _691536;
_691536 = 1 + _691535;
int _691530;
_691530 = 1 + _691529;
int _689078;
_689078 = 1 + _689077;
int _689072;
_689072 = 1 + _689071;
int _689066;
_689066 = 1 + _689065;
int _691437;
_691437 = 1 + _691436;
int _691431;
_691431 = 1 + _691430;
int _691425;
_691425 = 1 + _691424;
int _694889;
_694889 = 1 + _694888;
int _694883;
_694883 = 1 + _694882;
int _694877;
_694877 = 1 + _694876;
int _693657;
_693657 = 1 + _693656;
int _693651;
_693651 = 1 + _693650;
int _693645;
_693645 = 1 + _693644;
int _690064;
_690064 = 1 + _690063;
int _690058;
_690058 = 1 + _690057;
int _690052;
_690052 = 1 + _690051;
int _694185;
_694185 = 1 + _694184;
int _694179;
_694179 = 1 + _694178;
int _694173;
_694173 = 1 + _694172;
int _691401;
_691401 = 1 + _691400;
int _691395;
_691395 = 1 + _691394;
int _691389;
_691389 = 1 + _691388;
int _689536;
_689536 = 1 + _689535;
int _689530;
_689530 = 1 + _689529;
int _689524;
_689524 = 1 + _689523;
int _691824;
_691824 = 1 + _691823;
int _691818;
_691818 = 1 + _691817;
int _691812;
_691812 = 1 + _691811;
int _695417;
_695417 = 1 + _695416;
int _695411;
_695411 = 1 + _695410;
int _695405;
_695405 = 1 + _695404;
int _689008;
_689008 = 1 + _689007;
int _689002;
_689002 = 1 + _689001;
int _688996;
_688996 = 1 + _688995;
int _691965;
_691965 = 1 + _691964;
int _691959;
_691959 = 1 + _691958;
int _691953;
_691953 = 1 + _691952;
int _689227;
_689227 = 2 * _689226;
int _689755;
_689755 = 2 * _689754;
int _689086;
_689086 = 2 * _689085;
int _690424;
_690424 = 2 * _690423;
int _690706;
_690706 = 2 * _690705;
int _691163;
_691163 = 2 * _691162;
int _692219;
_692219 = 2 * _692218;
int _689966;
_689966 = 2 * _689965;
int _690987;
_690987 = 2 * _690986;
int _691093;
_691093 = 2 * _691092;
int _690811;
_690811 = 2 * _690810;
int _690248;
_690248 = 2 * _690247;
int _692114;
_692114 = 2 * _692113;
int _689931;
_689931 = 2 * _689930;
int _691339;
_691339 = 2 * _691338;
int _689333;
_689333 = 2 * _689332;
int _690002;
_690002 = 2 * _690001;
int _689861;
_689861 = 2 * _689860;
int _691058;
_691058 = 2 * _691057;
int _689790;
_689790 = 2 * _689789;
int _691128;
_691128 = 2 * _691127;
int _688910;
_688910 = 2 * _688909;
int _689896;
_689896 = 2 * _689895;
int _689262;
_689262 = 2 * _689261;
int _691304;
_691304 = 2 * _691303;
int _690494;
_690494 = 2 * _690493;
int _691480;
_691480 = 2 * _691479;
int _691586;
_691586 = 2 * _691585;
int _689157;
_689157 = 2 * _689156;
int _691656;
_691656 = 2 * _691655;
int _691726;
_691726 = 2 * _691725;
int _690459;
_690459 = 2 * _690458;
int _692254;
_692254 = 2 * _692253;
int _692149;
_692149 = 2 * _692148;
int _691022;
_691022 = 2 * _691021;
int _689122;
_689122 = 2 * _689121;
int _689650;
_689650 = 2 * _689649;
int _692008;
_692008 = 2 * _692007;
int _689192;
_689192 = 2 * _689191;
int _689826;
_689826 = 2 * _689825;
int _691234;
_691234 = 2 * _691233;
int _691577;
_691577 = 1 + _691576;
int _691571;
_691571 = 1 + _691570;
int _691565;
_691565 = 1 + _691564;
int _694291;
_694291 = 1 + _694290;
int _694285;
_694285 = 1 + _694284;
int _694279;
_694279 = 1 + _694278;
int _691100;
_691100 = 2 * _691099;
int _689868;
_689868 = 2 * _689867;
int _690255;
_690255 = 2 * _690254;
int _689797;
_689797 = 2 * _689796;
int _689903;
_689903 = 2 * _689902;
int _690501;
_690501 = 2 * _690500;
int _689657;
_689657 = 2 * _689656;
int _691241;
_691241 = 2 * _691240;
int _691487;
_691487 = 2 * _691486;
int _689340;
_689340 = 2 * _689339;
int _689762;
_689762 = 2 * _689761;
int _689938;
_689938 = 2 * _689937;
int _689973;
_689973 = 2 * _689972;
int _691170;
_691170 = 2 * _691169;
int _691346;
_691346 = 2 * _691345;
int _690713;
_690713 = 2 * _690712;
int _688917;
_688917 = 2 * _688916;
int _691311;
_691311 = 2 * _691310;
int _689129;
_689129 = 2 * _689128;
int _691593;
_691593 = 2 * _691592;
int _691733;
_691733 = 2 * _691732;
int _690009;
_690009 = 2 * _690008;
int _689269;
_689269 = 2 * _689268;
int _690818;
_690818 = 2 * _690817;
int _690994;
_690994 = 2 * _690993;
int _691135;
_691135 = 2 * _691134;
int _689164;
_689164 = 2 * _689163;
int _692015;
_692015 = 2 * _692014;
int _692156;
_692156 = 2 * _692155;
int _690466;
_690466 = 2 * _690465;
int _692121;
_692121 = 2 * _692120;
int _689093;
_689093 = 2 * _689092;
int _692226;
_692226 = 2 * _692225;
int _692261;
_692261 = 2 * _692260;
int _691663;
_691663 = 2 * _691662;
int _691065;
_691065 = 2 * _691064;
int _690431;
_690431 = 2 * _690430;
int _691029;
_691029 = 2 * _691028;
int _689833;
_689833 = 2 * _689832;
int _689234;
_689234 = 2 * _689233;
int _689199;
_689199 = 2 * _689198;
int _694784;
_694784 = 1 + _694783;
int _694778;
_694778 = 1 + _694777;
int _694772;
_694772 = 1 + _694771;
int _694819;
_694819 = 1 + _694818;
int _694813;
_694813 = 1 + _694812;
int _694807;
_694807 = 1 + _694806;
int _689571;
_689571 = 1 + _689570;
int _689565;
_689565 = 1 + _689564;
int _689559;
_689559 = 1 + _689558;
int _693024;
_693024 = 1 + _693023;
int _693018;
_693018 = 1 + _693017;
int _693012;
_693012 = 1 + _693011;
int _688832;
_688832 = 1 + _688831;
int _688826;
_688826 = 1 + _688825;
int _688820;
_688820 = 1 + _688819;
int _694713;
_694713 = 1 + _694712;
int _694707;
_694707 = 1 + _694706;
int _694701;
_694701 = 1 + _694700;
int _693340;
_693340 = 1 + _693339;
int _693334;
_693334 = 1 + _693333;
int _693328;
_693328 = 1 + _693327;
int _695312;
_695312 = 1 + _695311;
int _695306;
_695306 = 1 + _695305;
int _695300;
_695300 = 1 + _695299;
int _690134;
_690134 = 1 + _690133;
int _690128;
_690128 = 1 + _690127;
int _690122;
_690122 = 1 + _690121;
int _689712;
_689712 = 1 + _689711;
int _689706;
_689706 = 1 + _689705;
int _689700;
_689700 = 1 + _689699;
int _690592;
_690592 = 1 + _690591;
int _690586;
_690586 = 1 + _690585;
int _690580;
_690580 = 1 + _690579;
int _690416;
_690416 = 1 + _690415;
int _690410;
_690410 = 1 + _690409;
int _690404;
_690404 = 1 + _690403;
int _695593;
_695593 = 1 + _695592;
int _695587;
_695587 = 1 + _695586;
int _695581;
_695581 = 1 + _695580;
int _690205;
_690205 = 1 + _690204;
int _690199;
_690199 = 1 + _690198;
int _690193;
_690193 = 1 + _690192;
float _698517;
_698517 = _698515 + _698516;
int _691612;
_691612 = 2 * _691611;
int _691606;
_691606 = 2 * _691605;
int _691600;
_691600 = 2 * _691599;
int _691682;
_691682 = 2 * _691681;
int _691676;
_691676 = 2 * _691675;
int _691670;
_691670 = 2 * _691669;
int _691939;
_691939 = 1 + _691938;
int _691946;
_691946 = 1 + _691945;
float _697166;
_697166 = 6.000000e+00f * _697165;
float _698201;
_698201 = 6.000000e+00f * _698200;
int _695768;
_695768 = 2 * _695767;
int _695762;
_695762 = 2 * _695761;
int _695756;
_695756 = 2 * _695755;
int _695742;
_695742 = 2 * _695741;
int _695749;
_695749 = 2 * _695748;
int _695733;
_695733 = 2 * _695732;
int _695727;
_695727 = 2 * _695726;
int _695721;
_695721 = 2 * _695720;
int _695707;
_695707 = 2 * _695706;
int _695714;
_695714 = 2 * _695713;
int _695698;
_695698 = 2 * _695697;
int _695692;
_695692 = 2 * _695691;
int _695686;
_695686 = 2 * _695685;
int _695672;
_695672 = 2 * _695671;
int _695679;
_695679 = 2 * _695678;
int _695803;
_695803 = 2 * _695802;
int _695797;
_695797 = 2 * _695796;
int _695791;
_695791 = 2 * _695790;
int _695784;
_695784 = 2 * _695783;
int _695777;
_695777 = 2 * _695776;
float _696535;
_696535 = 4.000000e+00f * _696534;
float _696422;
_696422 = _696420 + _696421;
int _690390;
_690390 = 1 + _690389;
int _690397;
_690397 = 1 + _690396;
int _693938;
_693938 = 2 * _693937;
int _693932;
_693932 = 2 * _693931;
int _693926;
_693926 = 2 * _693925;
int _693912;
_693912 = 2 * _693911;
int _693919;
_693919 = 2 * _693918;
int _693903;
_693903 = 2 * _693902;
int _693897;
_693897 = 2 * _693896;
int _693891;
_693891 = 2 * _693890;
int _693877;
_693877 = 2 * _693876;
int _693884;
_693884 = 2 * _693883;
int _693973;
_693973 = 2 * _693972;
int _693967;
_693967 = 2 * _693966;
int _693961;
_693961 = 2 * _693960;
int _693947;
_693947 = 2 * _693946;
int _693954;
_693954 = 2 * _693953;
int _694043;
_694043 = 2 * _694042;
int _694037;
_694037 = 2 * _694036;
int _694031;
_694031 = 2 * _694030;
int _694017;
_694017 = 2 * _694016;
int _694024;
_694024 = 2 * _694023;
int _694008;
_694008 = 2 * _694007;
int _694002;
_694002 = 2 * _694001;
int _693996;
_693996 = 2 * _693995;
int _693982;
_693982 = 2 * _693981;
int _693989;
_693989 = 2 * _693988;
int _689922;
_689922 = 2 * _689921;
int _689916;
_689916 = 2 * _689915;
int _689910;
_689910 = 2 * _689909;
int _689887;
_689887 = 2 * _689886;
int _689881;
_689881 = 2 * _689880;
int _689875;
_689875 = 2 * _689874;
int _689852;
_689852 = 2 * _689851;
int _689846;
_689846 = 2 * _689845;
int _689840;
_689840 = 2 * _689839;
int _689992;
_689992 = 2 * _689991;
int _689986;
_689986 = 2 * _689985;
int _689980;
_689980 = 2 * _689979;
int _689957;
_689957 = 2 * _689956;
int _689951;
_689951 = 2 * _689950;
int _689945;
_689945 = 2 * _689944;
int _690143;
_690143 = 1 + _690142;
int _690150;
_690150 = 1 + _690149;
float _696768;
_696768 = 4.000000e+00f * _696767;
int _690179;
_690179 = 1 + _690178;
int _690186;
_690186 = 1 + _690185;
float _696053;
_696053 = _696039 + _696052;
float _696865;
_696865 = _696863 + _696864;
float _698323;
_698323 = 4.000000e+00f * _698322;
float _696325;
_696325 = _696323 + _696324;
int _691798;
_691798 = 1 + _691797;
int _691805;
_691805 = 1 + _691804;
float _696973;
_696973 = 4.000000e+00f * _696972;
float _696602;
_696602 = 4.000000e+00f * _696601;
float _696463;
_696463 = _696461 + _696462;
int _689686;
_689686 = 1 + _689685;
int _689693;
_689693 = 1 + _689692;
int _692811;
_692811 = 2 * _692810;
int _692805;
_692805 = 2 * _692804;
int _692799;
_692799 = 2 * _692798;
int _692785;
_692785 = 2 * _692784;
int _692792;
_692792 = 2 * _692791;
int _692776;
_692776 = 2 * _692775;
int _692770;
_692770 = 2 * _692769;
int _692764;
_692764 = 2 * _692763;
int _692750;
_692750 = 2 * _692749;
int _692757;
_692757 = 2 * _692756;
int _692671;
_692671 = 2 * _692670;
int _692665;
_692665 = 2 * _692664;
int _692659;
_692659 = 2 * _692658;
int _692645;
_692645 = 2 * _692644;
int _692652;
_692652 = 2 * _692651;
int _692706;
_692706 = 2 * _692705;
int _692700;
_692700 = 2 * _692699;
int _692694;
_692694 = 2 * _692693;
int _692680;
_692680 = 2 * _692679;
int _692687;
_692687 = 2 * _692686;
float _697431;
_697431 = _697417 + _697430;
int _695135;
_695135 = 2 * _695134;
int _695129;
_695129 = 2 * _695128;
int _695123;
_695123 = 2 * _695122;
int _695109;
_695109 = 2 * _695108;
int _695116;
_695116 = 2 * _695115;
int _695240;
_695240 = 2 * _695239;
int _695234;
_695234 = 2 * _695233;
int _695228;
_695228 = 2 * _695227;
int _695214;
_695214 = 2 * _695213;
int _695221;
_695221 = 2 * _695220;
float _697801;
_697801 = 4.000000e+00f * _697800;
int _691260;
_691260 = 2 * _691259;
int _691254;
_691254 = 2 * _691253;
int _691248;
_691248 = 2 * _691247;
int _691365;
_691365 = 2 * _691364;
int _691359;
_691359 = 2 * _691358;
int _691353;
_691353 = 2 * _691352;
int _691330;
_691330 = 2 * _691329;
int _691324;
_691324 = 2 * _691323;
int _691318;
_691318 = 2 * _691317;
float _698119;
_698119 = _698105 + _698118;
int _692530;
_692530 = 2 * _692529;
int _692524;
_692524 = 2 * _692523;
int _692518;
_692518 = 2 * _692517;
int _692504;
_692504 = 2 * _692503;
int _692511;
_692511 = 2 * _692510;
int _692600;
_692600 = 2 * _692599;
int _692594;
_692594 = 2 * _692593;
int _692588;
_692588 = 2 * _692587;
int _692574;
_692574 = 2 * _692573;
int _692581;
_692581 = 2 * _692580;
int _692635;
_692635 = 2 * _692634;
int _692629;
_692629 = 2 * _692628;
int _692623;
_692623 = 2 * _692622;
int _692609;
_692609 = 2 * _692608;
int _692616;
_692616 = 2 * _692615;
float _698284;
_698284 = 4.000000e+00f * _698283;
float* _693271;
_693271 = _453093_681168 + _693270;
float* _693265;
_693265 = _453093_681168 + _693264;
float* _693259;
_693259 = _453093_681168 + _693258;
float _695915;
_695915 = _695901 + _695914;
float _698392;
_698392 = 4.000000e+00f * _698391;
int _689299;
_689299 = 1 + _689298;
int _689306;
_689306 = 1 + _689305;
int _689369;
_689369 = 1 + _689368;
int _689376;
_689376 = 1 + _689375;
float _697786;
_697786 = _697784 + _697785;
int _690953;
_690953 = 1 + _690952;
int _690960;
_690960 = 1 + _690959;
float* _691121;
_691121 = _453093_681168 + _691120;
float* _691115;
_691115 = _453093_681168 + _691114;
float* _691109;
_691109 = _453093_681168 + _691108;
float* _694749;
_694749 = _453093_681168 + _694748;
float* _694743;
_694743 = _453093_681168 + _694742;
float* _694737;
_694737 = _453093_681168 + _694736;
int _690284;
_690284 = 1 + _690283;
int _690291;
_690291 = 1 + _690290;
int _691516;
_691516 = 1 + _691515;
int _691523;
_691523 = 1 + _691522;
int _688947;
_688947 = 1 + _688946;
int _688954;
_688954 = 1 + _688953;
float* _695524;
_695524 = _453093_681168 + _695523;
float* _695518;
_695518 = _453093_681168 + _695517;
float* _695512;
_695512 = _453093_681168 + _695511;
int _692044;
_692044 = 1 + _692043;
int _692051;
_692051 = 1 + _692050;
float _696563;
_696563 = 4.000000e+00f * _696562;
float* _690487;
_690487 = _453093_681168 + _690486;
float* _690481;
_690481 = _453093_681168 + _690480;
float* _690475;
_690475 = _453093_681168 + _690474;
int _690319;
_690319 = 1 + _690318;
int _690326;
_690326 = 1 + _690325;
float* _694327;
_694327 = _453093_681168 + _694326;
float* _694321;
_694321 = _453093_681168 + _694320;
float* _694315;
_694315 = _453093_681168 + _694314;
float _696231;
_696231 = _696229 + _696230;
int _691270;
_691270 = 1 + _691269;
int _691277;
_691277 = 1 + _691276;
float _698049;
_698049 = 4.000000e+00f * _698048;
float _696024;
_696024 = _696022 + _696023;
int _689439;
_689439 = 1 + _689438;
int _689446;
_689446 = 1 + _689445;
float _697457;
_697457 = _697455 + _697456;
int _691551;
_691551 = 1 + _691550;
int _691558;
_691558 = 1 + _691557;
float _696148;
_696148 = _696146 + _696147;
int _692079;
_692079 = 1 + _692078;
int _692086;
_692086 = 1 + _692085;
float _696189;
_696189 = _696187 + _696188;
float* _695629;
_695629 = _453093_681168 + _695628;
float* _695623;
_695623 = _453093_681168 + _695622;
float* _695617;
_695617 = _453093_681168 + _695616;
int _691411;
_691411 = 1 + _691410;
int _691418;
_691418 = 1 + _691417;
float _698145;
_698145 = _698143 + _698144;
float _697070;
_697070 = _697068 + _697069;
int _693727;
_693727 = 2 * _693726;
int _693721;
_693721 = 2 * _693720;
int _693715;
_693715 = 2 * _693714;
int _693701;
_693701 = 2 * _693700;
int _693708;
_693708 = 2 * _693707;
int _693797;
_693797 = 2 * _693796;
int _693791;
_693791 = 2 * _693790;
int _693785;
_693785 = 2 * _693784;
int _693771;
_693771 = 2 * _693770;
int _693778;
_693778 = 2 * _693777;
int _693832;
_693832 = 2 * _693831;
int _693826;
_693826 = 2 * _693825;
int _693820;
_693820 = 2 * _693819;
int _693806;
_693806 = 2 * _693805;
int _693813;
_693813 = 2 * _693812;
int _693762;
_693762 = 2 * _693761;
int _693756;
_693756 = 2 * _693755;
int _693750;
_693750 = 2 * _693749;
int _693736;
_693736 = 2 * _693735;
int _693743;
_693743 = 2 * _693742;
int _693867;
_693867 = 2 * _693866;
int _693861;
_693861 = 2 * _693860;
int _693855;
_693855 = 2 * _693854;
int _693841;
_693841 = 2 * _693840;
int _693848;
_693848 = 2 * _693847;
float _695982;
_695982 = _695980 + _695981;
int _695029;
_695029 = 2 * _695028;
int _695023;
_695023 = 2 * _695022;
int _695017;
_695017 = 2 * _695016;
int _695003;
_695003 = 2 * _695002;
int _695010;
_695010 = 2 * _695009;
int _695099;
_695099 = 2 * _695098;
int _695093;
_695093 = 2 * _695092;
int _695087;
_695087 = 2 * _695086;
int _695073;
_695073 = 2 * _695072;
int _695080;
_695080 = 2 * _695079;
int _695064;
_695064 = 2 * _695063;
int _695058;
_695058 = 2 * _695057;
int _695052;
_695052 = 2 * _695051;
int _695038;
_695038 = 2 * _695037;
int _695045;
_695045 = 2 * _695044;
int _688982;
_688982 = 1 + _688981;
int _688989;
_688989 = 1 + _688988;
float _695929;
_695929 = _695915 + _695928;
float _696879;
_696879 = _696865 + _696878;
int _691692;
_691692 = 1 + _691691;
int _691699;
_691699 = 1 + _691698;
float _696492;
_696492 = 4.000000e+00f * _696491;
int _689580;
_689580 = 1 + _689579;
int _689587;
_689587 = 1 + _689586;
float* _695277;
_695277 = _453093_681168 + _695276;
float* _695271;
_695271 = _453093_681168 + _695270;
float* _695265;
_695265 = _453093_681168 + _695264;
int _689183;
_689183 = 2 * _689182;
int _689177;
_689177 = 2 * _689176;
int _689171;
_689171 = 2 * _689170;
int _689288;
_689288 = 2 * _689287;
int _689282;
_689282 = 2 * _689281;
int _689276;
_689276 = 2 * _689275;
int _689218;
_689218 = 2 * _689217;
int _689212;
_689212 = 2 * _689211;
int _689206;
_689206 = 2 * _689205;
int _689253;
_689253 = 2 * _689252;
int _689247;
_689247 = 2 * _689246;
int _689241;
_689241 = 2 * _689240;
int _689148;
_689148 = 2 * _689147;
int _689142;
_689142 = 2 * _689141;
int _689136;
_689136 = 2 * _689135;
float _697193;
_697193 = _697191 + _697192;
float* _689114;
_689114 = _453093_681168 + _689113;
float* _689108;
_689108 = _453093_681168 + _689107;
float* _689102;
_689102 = _453093_681168 + _689101;
float* _690734;
_690734 = _453093_681168 + _690733;
float* _690728;
_690728 = _453093_681168 + _690727;
float* _690722;
_690722 = _453093_681168 + _690721;
float _698530;
_698530 = 4.000000e+00f * _698529;
float _698557;
_698557 = _698555 + _698556;
float _697760;
_697760 = _697758 + _697759;
float _697180;
_697180 = 4.000000e+00f * _697179;
float _698405;
_698405 = _698403 + _698404;
float _695955;
_695955 = _695953 + _695954;
float* _691754;
_691754 = _453093_681168 + _691753;
float* _691748;
_691748 = _453093_681168 + _691747;
float* _691742;
_691742 = _453093_681168 + _691741;
int _692459;
_692459 = 2 * _692458;
int _692453;
_692453 = 2 * _692452;
int _692447;
_692447 = 2 * _692446;
int _692433;
_692433 = 2 * _692432;
int _692440;
_692440 = 2 * _692439;
int _692424;
_692424 = 2 * _692423;
int _692418;
_692418 = 2 * _692417;
int _692412;
_692412 = 2 * _692411;
int _692398;
_692398 = 2 * _692397;
int _692405;
_692405 = 2 * _692404;
int _692319;
_692319 = 2 * _692318;
int _692313;
_692313 = 2 * _692312;
int _692307;
_692307 = 2 * _692306;
int _692292;
_692292 = 2 * _692291;
int _692300;
_692300 = 2 * _692299;
int _692389;
_692389 = 2 * _692388;
int _692383;
_692383 = 2 * _692382;
int _692377;
_692377 = 2 * _692376;
int _692363;
_692363 = 2 * _692362;
int _692370;
_692370 = 2 * _692369;
int _692354;
_692354 = 2 * _692353;
int _692348;
_692348 = 2 * _692347;
int _692342;
_692342 = 2 * _692341;
int _692328;
_692328 = 2 * _692327;
int _692335;
_692335 = 2 * _692334;
int _689510;
_689510 = 1 + _689509;
int _689517;
_689517 = 1 + _689516;
float _697305;
_697305 = _697303 + _697304;
float _698215;
_698215 = 4.000000e+00f * _698214;
float _697540;
_697540 = _697538 + _697539;
float* _689783;
_689783 = _453093_681168 + _689782;
float* _689777;
_689777 = _453093_681168 + _689776;
float* _689771;
_689771 = _453093_681168 + _689770;
float _698090;
_698090 = _698088 + _698089;
float _697993;
_697993 = _697991 + _697992;
float _697499;
_697499 = 4.000000e+00f * _697498;
float _698271;
_698271 = _698257 + _698270;
float _697292;
_697292 = 4.000000e+00f * _697291;
float* _691156;
_691156 = _453093_681168 + _691155;
float* _691150;
_691150 = _453093_681168 + _691149;
float* _691144;
_691144 = _453093_681168 + _691143;
float _698474;
_698474 = _698472 + _698473;
int _691375;
_691375 = 1 + _691374;
int _691382;
_691382 = 1 + _691381;
int _691763;
_691763 = 1 + _691762;
int _691770;
_691770 = 1 + _691769;
float _696244;
_696244 = _696242 + _696243;
float _696284;
_696284 = _696282 + _696283;
float* _689678;
_689678 = _453093_681168 + _689677;
float* _689672;
_689672 = _453093_681168 + _689671;
float* _689666;
_689666 = _453093_681168 + _689665;
float* _693377;
_693377 = _453093_681168 + _693376;
float* _693371;
_693371 = _453093_681168 + _693370;
float* _693365;
_693365 = _453093_681168 + _693364;
float _697928;
_697928 = _697914 + _697927;
float _697226;
_697226 = _697212 + _697225;
int _692245;
_692245 = 2 * _692244;
int _692239;
_692239 = 2 * _692238;
int _692233;
_692233 = 2 * _692232;
int _692280;
_692280 = 2 * _692279;
int _692274;
_692274 = 2 * _692273;
int _692268;
_692268 = 2 * _692267;
int _692175;
_692175 = 2 * _692174;
int _692169;
_692169 = 2 * _692168;
int _692163;
_692163 = 2 * _692162;
int _692140;
_692140 = 2 * _692139;
int _692134;
_692134 = 2 * _692133;
int _692128;
_692128 = 2 * _692127;
float _698351;
_698351 = 4.000000e+00f * _698350;
int _691974;
_691974 = 1 + _691973;
int _691981;
_691981 = 1 + _691980;
float _696136;
_696136 = _696122 + _696135;
float _697319;
_697319 = _697317 + _697318;
float* _690522;
_690522 = _453093_681168 + _690521;
float* _690516;
_690516 = _453093_681168 + _690515;
float* _690510;
_690510 = _453093_681168 + _690509;
float* _694573;
_694573 = _453093_681168 + _694572;
float* _694567;
_694567 = _453093_681168 + _694566;
float* _694561;
_694561 = _453093_681168 + _694560;
float _698419;
_698419 = _698417 + _698418;
float _696258;
_696258 = _696244 + _696257;
float* _689818;
_689818 = _453093_681168 + _689817;
float* _689812;
_689812 = _453093_681168 + _689811;
float* _689806;
_689806 = _453093_681168 + _689805;
float* _694221;
_694221 = _453093_681168 + _694220;
float* _694215;
_694215 = _453093_681168 + _694214;
float* _694209;
_694209 = _453093_681168 + _694208;
float _697083;
_697083 = 4.000000e+00f * _697082;
float _697486;
_697486 = _697484 + _697485;
int _689545;
_689545 = 1 + _689544;
int _689552;
_689552 = 1 + _689551;
float _697555;
_697555 = _697553 + _697554;
float _696408;
_696408 = _696406 + _696407;
float _696836;
_696836 = _696834 + _696835;
float _696162;
_696162 = _696160 + _696161;
float _696589;
_696589 = _696587 + _696588;
int _692185;
_692185 = 1 + _692184;
int _692192;
_692192 = 1 + _692191;
float _698187;
_698187 = 4.000000e+00f * _698186;
float _697979;
_697979 = _697977 + _697978;
int _690038;
_690038 = 1 + _690037;
int _690045;
_690045 = 1 + _690044;
float _698008;
_698008 = 4.000000e+00f * _698007;
float _696671;
_696671 = 4.000000e+00f * _696670;
int _689721;
_689721 = 1 + _689720;
int _689728;
_689728 = 1 + _689727;
int _690918;
_690918 = 1 + _690917;
int _690925;
_690925 = 1 + _690924;
float* _691508;
_691508 = _453093_681168 + _691507;
float* _691502;
_691502 = _453093_681168 + _691501;
float* _691496;
_691496 = _453093_681168 + _691495;
float _696986;
_696986 = _696984 + _696985;
float* _694538;
_694538 = _453093_681168 + _694537;
float* _694532;
_694532 = _453093_681168 + _694531;
float* _694526;
_694526 = _453093_681168 + _694525;
float _698488;
_698488 = _698486 + _698487;
float _697855;
_697855 = _697853 + _697854;
float _696699;
_696699 = 4.000000e+00f * _696698;
int _689475;
_689475 = 1 + _689474;
int _689482;
_689482 = 1 + _689481;
float _698297;
_698297 = _698295 + _698296;
float* _689361;
_689361 = _453093_681168 + _689360;
float* _689355;
_689355 = _453093_681168 + _689354;
float* _689349;
_689349 = _453093_681168 + _689348;
float _698076;
_698076 = _698074 + _698075;
float _697015;
_697015 = _697001 + _697014;
float* _690452;
_690452 = _453093_681168 + _690451;
float* _690446;
_690446 = _453093_681168 + _690445;
float* _690440;
_690440 = _453093_681168 + _690439;
float _696905;
_696905 = _696903 + _696904;
int _689615;
_689615 = 1 + _689614;
int _689622;
_689622 = 1 + _689621;
float _698393;
_698393 = _698379 + _698392;
int _691622;
_691622 = 1 + _691621;
int _691629;
_691629 = 1 + _691628;
float _696946;
_696946 = _696932 + _696945;
int _690531;
_690531 = 1 + _690530;
int _690538;
_690538 = 1 + _690537;
float* _695489;
_695489 = _453093_681168 + _695488;
float* _695483;
_695483 = _453093_681168 + _695482;
float* _695477;
_695477 = _453093_681168 + _695476;
float _696272;
_696272 = _696258 + _696271;
int _690355;
_690355 = 1 + _690354;
int _690362;
_690362 = 1 + _690361;
float _697376;
_697376 = _697362 + _697375;
int _691199;
_691199 = 1 + _691198;
int _691206;
_691206 = 1 + _691205;
int _689404;
_689404 = 1 + _689403;
int _689411;
_689411 = 1 + _689410;
int _690073;
_690073 = 1 + _690072;
int _690080;
_690080 = 1 + _690079;
int _690108;
_690108 = 1 + _690107;
int _690115;
_690115 = 1 + _690114;
int _689052;
_689052 = 1 + _689051;
int _689059;
_689059 = 1 + _689058;
int _689017;
_689017 = 1 + _689016;
int _689024;
_689024 = 1 + _689023;
int _690883;
_690883 = 1 + _690882;
int _690890;
_690890 = 1 + _690889;
float* _693412;
_693412 = _453093_681168 + _693411;
float* _693406;
_693406 = _453093_681168 + _693405;
float* _693400;
_693400 = _453093_681168 + _693399;
float _697444;
_697444 = 6.000000e+00f * _697443;
float* _692919;
_692919 = _453093_681168 + _692918;
float* _692913;
_692913 = _453093_681168 + _692912;
float* _692907;
_692907 = _453093_681168 + _692906;
float* _691086;
_691086 = _453093_681168 + _691085;
float* _691080;
_691080 = _453093_681168 + _691079;
float* _691074;
_691074 = _453093_681168 + _691073;
float _696478;
_696478 = 6.000000e+00f * _696477;
float _697705;
_697705 = _697691 + _697704;
int _690566;
_690566 = 1 + _690565;
int _690573;
_690573 = 1 + _690572;
int _690636;
_690636 = 1 + _690635;
int _690643;
_690643 = 1 + _690642;
int _690601;
_690601 = 1 + _690600;
int _690608;
_690608 = 1 + _690607;
int _690671;
_690671 = 1 + _690670;
int _690678;
_690678 = 1 + _690677;
int _691446;
_691446 = 1 + _691445;
int _691453;
_691453 = 1 + _691452;
float* _694468;
_694468 = _453093_681168 + _694467;
float* _694462;
_694462 = _453093_681168 + _694461;
float* _694456;
_694456 = _453093_681168 + _694455;
float _697774;
_697774 = _697760 + _697773;
float _697635;
_697635 = 4.000000e+00f * _697634;
float* _692989;
_692989 = _453093_681168 + _692988;
float* _692983;
_692983 = _453093_681168 + _692982;
float* _692977;
_692977 = _453093_681168 + _692976;
int _690847;
_690847 = 1 + _690846;
int _690854;
_690854 = 1 + _690853;
int _690742;
_690742 = 1 + _690741;
int _690749;
_690749 = 1 + _690748;
int _690777;
_690777 = 1 + _690776;
int _690784;
_690784 = 1 + _690783;
float _696067;
_696067 = _696053 + _696066;
float* _693236;
_693236 = _453093_681168 + _693235;
float* _693230;
_693230 = _453093_681168 + _693229;
float* _693224;
_693224 = _453093_681168 + _693223;
float* _691015;
_691015 = _453093_681168 + _691014;
float* _691009;
_691009 = _453093_681168 + _691008;
float* _691003;
_691003 = _453093_681168 + _691002;
float _696741;
_696741 = _696727 + _696740;
float* _690839;
_690839 = _453093_681168 + _690838;
float* _690833;
_690833 = _453093_681168 + _690832;
float* _690827;
_690827 = _453093_681168 + _690826;
float _697029;
_697029 = _697015 + _697028;
float _697253;
_697253 = 4.000000e+00f * _697252;
int _688841;
_688841 = 1 + _688840;
int _688848;
_688848 = 1 + _688847;
int _688770;
_688770 = 1 + _688769;
int _688778;
_688778 = 1 + _688777;
int _688876;
_688876 = 1 + _688875;
int _688883;
_688883 = 1 + _688882;
int _688806;
_688806 = 1 + _688805;
int _688813;
_688813 = 1 + _688812;
float _696810;
_696810 = _696796 + _696809;
int _690214;
_690214 = 1 + _690213;
int _690221;
_690221 = 1 + _690220;
float* _691191;
_691191 = _453093_681168 + _691190;
float* _691185;
_691185 = _453093_681168 + _691184;
float* _691179;
_691179 = _453093_681168 + _691178;
float* _691050;
_691050 = _453093_681168 + _691049;
float* _691044;
_691044 = _453093_681168 + _691043;
float* _691038;
_691038 = _453093_681168 + _691037;
float* _690276;
_690276 = _453093_681168 + _690275;
float* _690270;
_690270 = _453093_681168 + _690269;
float* _690264;
_690264 = _453093_681168 + _690263;
int _691903;
_691903 = 1 + _691902;
int _691910;
_691910 = 1 + _691909;
int _691868;
_691868 = 1 + _691867;
int _691875;
_691875 = 1 + _691874;
int _691833;
_691833 = 1 + _691832;
int _691840;
_691840 = 1 + _691839;
float _697732;
_697732 = 4.000000e+00f * _697731;
float* _694644;
_694644 = _453093_681168 + _694643;
float* _694638;
_694638 = _453093_681168 + _694637;
float* _694632;
_694632 = _453093_681168 + _694631;
float _695997;
_695997 = 6.000000e+00f * _695996;
float _697390;
_697390 = _697376 + _697389;
float* _693553;
_693553 = _453093_681168 + _693552;
float* _693547;
_693547 = _453093_681168 + _693546;
float* _693541;
_693541 = _453093_681168 + _693540;
float _697152;
_697152 = 4.000000e+00f * _697151;
float _697718;
_697718 = 6.000000e+00f * _697717;
float _698132;
_698132 = 6.000000e+00f * _698131;
float _695848;
_695848 = _695834 + _695847;
float _696396;
_696396 = _696382 + _696395;
float _698462;
_698462 = _698448 + _698461;
float* _688938;
_688938 = _453093_681168 + _688937;
float* _688932;
_688932 = _453093_681168 + _688931;
float* _688926;
_688926 = _453093_681168 + _688925;
float* _694116;
_694116 = _453093_681168 + _694115;
float* _694110;
_694110 = _453093_681168 + _694109;
float* _694104;
_694104 = _453093_681168 + _694103;
float* _692036;
_692036 = _453093_681168 + _692035;
float* _692030;
_692030 = _453093_681168 + _692029;
float* _692024;
_692024 = _453093_681168 + _692023;
float* _693095;
_693095 = _453093_681168 + _693094;
float* _693089;
_693089 = _453093_681168 + _693088;
float* _693083;
_693083 = _453093_681168 + _693082;
float* _692884;
_692884 = _453093_681168 + _692883;
float* _692878;
_692878 = _453093_681168 + _692877;
float* _692872;
_692872 = _453093_681168 + _692871;
float* _694257;
_694257 = _453093_681168 + _694256;
float* _694251;
_694251 = _453093_681168 + _694250;
float* _694245;
_694245 = _453093_681168 + _694244;
float* _691473;
_691473 = _453093_681168 + _691472;
float* _691467;
_691467 = _453093_681168 + _691466;
float* _691461;
_691461 = _453093_681168 + _691460;
float* _692954;
_692954 = _453093_681168 + _692953;
float* _692948;
_692948 = _453093_681168 + _692947;
float* _692942;
_692942 = _453093_681168 + _692941;
float* _690910;
_690910 = _453093_681168 + _690909;
float* _690904;
_690904 = _453093_681168 + _690903;
float* _690898;
_690898 = _453093_681168 + _690897;
float* _691226;
_691226 = _453093_681168 + _691225;
float* _691220;
_691220 = _453093_681168 + _691219;
float* _691214;
_691214 = _453093_681168 + _691213;
float* _688903;
_688903 = _453093_681168 + _688902;
float* _688897;
_688897 = _453093_681168 + _688896;
float* _688891;
_688891 = _453093_681168 + _688890;
float* _690030;
_690030 = _453093_681168 + _690029;
float* _690024;
_690024 = _453093_681168 + _690023;
float* _690018;
_690018 = _453093_681168 + _690017;
float* _693060;
_693060 = _453093_681168 + _693059;
float* _693054;
_693054 = _453093_681168 + _693053;
float* _693048;
_693048 = _453093_681168 + _693047;
float* _692071;
_692071 = _453093_681168 + _692070;
float* _692065;
_692065 = _453093_681168 + _692064;
float* _692059;
_692059 = _453093_681168 + _692058;
float* _694925;
_694925 = _453093_681168 + _694924;
float* _694919;
_694919 = _453093_681168 + _694918;
float* _694913;
_694913 = _453093_681168 + _694912;
float* _693130;
_693130 = _453093_681168 + _693129;
float* _693124;
_693124 = _453093_681168 + _693123;
float* _693118;
_693118 = _453093_681168 + _693117;
float* _695348;
_695348 = _453093_681168 + _695347;
float* _695342;
_695342 = _453093_681168 + _695341;
float* _695336;
_695336 = _453093_681168 + _695335;
float* _692001;
_692001 = _453093_681168 + _692000;
float* _691995;
_691995 = _453093_681168 + _691994;
float* _691989;
_691989 = _453093_681168 + _691988;
float* _688868;
_688868 = _453093_681168 + _688867;
float* _688862;
_688862 = _453093_681168 + _688861;
float* _688856;
_688856 = _453093_681168 + _688855;
float* _690382;
_690382 = _453093_681168 + _690381;
float* _690376;
_690376 = _453093_681168 + _690375;
float* _690370;
_690370 = _453093_681168 + _690369;
float* _694679;
_694679 = _453093_681168 + _694678;
float* _694673;
_694673 = _453093_681168 + _694672;
float* _694667;
_694667 = _453093_681168 + _694666;
float* _693517;
_693517 = _453093_681168 + _693516;
float* _693511;
_693511 = _453093_681168 + _693510;
float* _693505;
_693505 = _453093_681168 + _693504;
float* _693165;
_693165 = _453093_681168 + _693164;
float* _693159;
_693159 = _453093_681168 + _693158;
float* _693153;
_693153 = _453093_681168 + _693152;
float* _695207;
_695207 = _453093_681168 + _695206;
float* _695201;
_695201 = _453093_681168 + _695200;
float* _695195;
_695195 = _453093_681168 + _695194;
float* _690769;
_690769 = _453093_681168 + _690768;
float* _690763;
_690763 = _453093_681168 + _690762;
float* _690757;
_690757 = _453093_681168 + _690756;
float* _688974;
_688974 = _453093_681168 + _688973;
float* _688968;
_688968 = _453093_681168 + _688967;
float* _688962;
_688962 = _453093_681168 + _688961;
float* _688798;
_688798 = _453093_681168 + _688797;
float* _688792;
_688792 = _453093_681168 + _688791;
float* _688786;
_688786 = _453093_681168 + _688785;
float* _690874;
_690874 = _453093_681168 + _690873;
float* _690868;
_690868 = _453093_681168 + _690867;
float* _690862;
_690862 = _453093_681168 + _690861;
float* _689607;
_689607 = _453093_681168 + _689606;
float* _689601;
_689601 = _453093_681168 + _689600;
float* _689595;
_689595 = _453093_681168 + _689594;
float* _693693;
_693693 = _453093_681168 + _693692;
float* _693687;
_693687 = _453093_681168 + _693686;
float* _693681;
_693681 = _453093_681168 + _693680;
float* _693623;
_693623 = _453093_681168 + _693622;
float* _693617;
_693617 = _453093_681168 + _693616;
float* _693611;
_693611 = _453093_681168 + _693610;
float* _692497;
_692497 = _453093_681168 + _692496;
float* _692491;
_692491 = _453093_681168 + _692490;
float* _692485;
_692485 = _453093_681168 + _692484;
float* _693306;
_693306 = _453093_681168 + _693305;
float* _693300;
_693300 = _453093_681168 + _693299;
float* _693294;
_693294 = _453093_681168 + _693293;
float* _692849;
_692849 = _453093_681168 + _692848;
float* _692843;
_692843 = _453093_681168 + _692842;
float* _692837;
_692837 = _453093_681168 + _692836;
float* _692567;
_692567 = _453093_681168 + _692566;
float* _692561;
_692561 = _453093_681168 + _692560;
float* _692555;
_692555 = _453093_681168 + _692554;
float* _694362;
_694362 = _453093_681168 + _694361;
float* _694356;
_694356 = _453093_681168 + _694355;
float* _694350;
_694350 = _453093_681168 + _694349;
float* _693588;
_693588 = _453093_681168 + _693587;
float* _693582;
_693582 = _453093_681168 + _693581;
float* _693576;
_693576 = _453093_681168 + _693575;
float* _690558;
_690558 = _453093_681168 + _690557;
float* _690552;
_690552 = _453093_681168 + _690551;
float* _690546;
_690546 = _453093_681168 + _690545;
float* _691297;
_691297 = _453093_681168 + _691296;
float* _691291;
_691291 = _453093_681168 + _691290;
float* _691285;
_691285 = _453093_681168 + _691284;
float* _694996;
_694996 = _453093_681168 + _694995;
float* _694990;
_694990 = _453093_681168 + _694989;
float* _694984;
_694984 = _453093_681168 + _694983;
float* _694397;
_694397 = _453093_681168 + _694396;
float* _694391;
_694391 = _453093_681168 + _694390;
float* _694385;
_694385 = _453093_681168 + _694384;
float* _695665;
_695665 = _453093_681168 + _695664;
float* _695659;
_695659 = _453093_681168 + _695658;
float* _695653;
_695653 = _453093_681168 + _695652;
float* _694609;
_694609 = _453093_681168 + _694608;
float* _694603;
_694603 = _453093_681168 + _694602;
float* _694597;
_694597 = _453093_681168 + _694596;
float* _691860;
_691860 = _453093_681168 + _691859;
float* _691854;
_691854 = _453093_681168 + _691853;
float* _691848;
_691848 = _453093_681168 + _691847;
float* _691895;
_691895 = _453093_681168 + _691894;
float* _691889;
_691889 = _453093_681168 + _691888;
float* _691883;
_691883 = _453093_681168 + _691882;
float* _690698;
_690698 = _453093_681168 + _690697;
float* _690692;
_690692 = _453093_681168 + _690691;
float* _690686;
_690686 = _453093_681168 + _690685;
int _695644;
_695644 = 2 * _695643;
int _692546;
_692546 = 2 * _692545;
int _694517;
_694517 = 2 * _694516;
int _693496;
_693496 = 2 * _693495;
int _694341;
_694341 = 2 * _694340;
int _694060;
_694060 = 2 * _694059;
int _694658;
_694658 = 2 * _694657;
int _694482;
_694482 = 2 * _694481;
int _694764;
_694764 = 2 * _694763;
int _695468;
_695468 = 2 * _695467;
int _695397;
_695397 = 2 * _695396;
int _693180;
_693180 = 2 * _693179;
int _693461;
_693461 = 2 * _693460;
int _694306;
_694306 = 2 * _694305;
int _695256;
_695256 = 2 * _695255;
int _694552;
_694552 = 2 * _694551;
int _693250;
_693250 = 2 * _693249;
int _693672;
_693672 = 2 * _693671;
int _692863;
_692863 = 2 * _692862;
int _693602;
_693602 = 2 * _693601;
int _694869;
_694869 = 2 * _694868;
int _694623;
_694623 = 2 * _694622;
int _693109;
_693109 = 2 * _693108;
int _693215;
_693215 = 2 * _693214;
int _693637;
_693637 = 2 * _693636;
int _694165;
_694165 = 2 * _694164;
int _695432;
_695432 = 2 * _695431;
int _693144;
_693144 = 2 * _693143;
int _695151;
_695151 = 2 * _695150;
int _695327;
_695327 = 2 * _695326;
int _693004;
_693004 = 2 * _693003;
int _695538;
_695538 = 2 * _695537;
int _693532;
_693532 = 2 * _693531;
int _692828;
_692828 = 2 * _692827;
int _694130;
_694130 = 2 * _694129;
int _694236;
_694236 = 2 * _694235;
int _693391;
_693391 = 2 * _693390;
int _694940;
_694940 = 2 * _694939;
int _692933;
_692933 = 2 * _692932;
int _694376;
_694376 = 2 * _694375;
int _693039;
_693039 = 2 * _693038;
int _695362;
_695362 = 2 * _695361;
int _693426;
_693426 = 2 * _693425;
int _695186;
_695186 = 2 * _695185;
int _694834;
_694834 = 2 * _694833;
int _694412;
_694412 = 2 * _694411;
int _694799;
_694799 = 2 * _694798;
int _695573;
_695573 = 2 * _695572;
int _694447;
_694447 = 2 * _694446;
int _692968;
_692968 = 2 * _692967;
int _694693;
_694693 = 2 * _694692;
int _692476;
_692476 = 2 * _692475;
int _693285;
_693285 = 2 * _693284;
int _692722;
_692722 = 2 * _692721;
int _693356;
_693356 = 2 * _693355;
int _693320;
_693320 = 2 * _693319;
int _694200;
_694200 = 2 * _694199;
int _695292;
_695292 = 2 * _695291;
int _693567;
_693567 = 2 * _693566;
int _694975;
_694975 = 2 * _694974;
int _694728;
_694728 = 2 * _694727;
int _693074;
_693074 = 2 * _693073;
int _695503;
_695503 = 2 * _695502;
int _692898;
_692898 = 2 * _692897;
int _694588;
_694588 = 2 * _694587;
int _694095;
_694095 = 2 * _694094;
int _694904;
_694904 = 2 * _694903;
int _695608;
_695608 = 2 * _695607;
int _694271;
_694271 = 2 * _694270;
int _693278;
_693278 = 2 * _693277;
int _694158;
_694158 = 2 * _694157;
int _695355;
_695355 = 2 * _695354;
int _694968;
_694968 = 2 * _694967;
int _694792;
_694792 = 2 * _694791;
int _694757;
_694757 = 2 * _694756;
int _694229;
_694229 = 2 * _694228;
int _695566;
_695566 = 2 * _695565;
int _693208;
_693208 = 2 * _693207;
int _693102;
_693102 = 2 * _693101;
int _694545;
_694545 = 2 * _694544;
int _694616;
_694616 = 2 * _694615;
int _694686;
_694686 = 2 * _694685;
int _692997;
_692997 = 2 * _692996;
int _692961;
_692961 = 2 * _692960;
int _692926;
_692926 = 2 * _692925;
int _693419;
_693419 = 2 * _693418;
int _693489;
_693489 = 2 * _693488;
int _693173;
_693173 = 2 * _693172;
int _695425;
_695425 = 2 * _695424;
int _692715;
_692715 = 2 * _692714;
int _695179;
_695179 = 2 * _695178;
int _694193;
_694193 = 2 * _694192;
int _692891;
_692891 = 2 * _692890;
int _695390;
_695390 = 2 * _695389;
int _694053;
_694053 = 2 * _694052;
int _693313;
_693313 = 2 * _693312;
int _695320;
_695320 = 2 * _695319;
int _694581;
_694581 = 2 * _694580;
int _693067;
_693067 = 2 * _693066;
int _693349;
_693349 = 2 * _693348;
int _694264;
_694264 = 2 * _694263;
int _692821;
_692821 = 2 * _692820;
int _693137;
_693137 = 2 * _693136;
int _695637;
_695637 = 2 * _695636;
int _694510;
_694510 = 2 * _694509;
int _692469;
_692469 = 2 * _692468;
int _694827;
_694827 = 2 * _694826;
int _695285;
_695285 = 2 * _695284;
int _694299;
_694299 = 2 * _694298;
int _693525;
_693525 = 2 * _693524;
int _694897;
_694897 = 2 * _694896;
int _694123;
_694123 = 2 * _694122;
int _695144;
_695144 = 2 * _695143;
int _693595;
_693595 = 2 * _693594;
int _693243;
_693243 = 2 * _693242;
int _694475;
_694475 = 2 * _694474;
int _694721;
_694721 = 2 * _694720;
int _695461;
_695461 = 2 * _695460;
int _693032;
_693032 = 2 * _693031;
int _695249;
_695249 = 2 * _695248;
int _694651;
_694651 = 2 * _694650;
int _694334;
_694334 = 2 * _694333;
int _693454;
_693454 = 2 * _693453;
int _695601;
_695601 = 2 * _695600;
int _693630;
_693630 = 2 * _693629;
int _692856;
_692856 = 2 * _692855;
int _694440;
_694440 = 2 * _694439;
int _693665;
_693665 = 2 * _693664;
int _693560;
_693560 = 2 * _693559;
int _694088;
_694088 = 2 * _694087;
int _693384;
_693384 = 2 * _693383;
int _692539;
_692539 = 2 * _692538;
int _695531;
_695531 = 2 * _695530;
int _695496;
_695496 = 2 * _695495;
int _694933;
_694933 = 2 * _694932;
int _694369;
_694369 = 2 * _694368;
int _694405;
_694405 = 2 * _694404;
int _694862;
_694862 = 2 * _694861;
float* _694433;
_694433 = _453093_681168 + _694432;
float* _694427;
_694427 = _453093_681168 + _694426;
float* _694421;
_694421 = _453093_681168 + _694420;
float* _690346;
_690346 = _453093_681168 + _690345;
float* _690340;
_690340 = _453093_681168 + _690339;
float* _690334;
_690334 = _453093_681168 + _690333;
float* _690804;
_690804 = _453093_681168 + _690803;
float* _690798;
_690798 = _453093_681168 + _690797;
float* _690792;
_690792 = _453093_681168 + _690791;
float* _692212;
_692212 = _453093_681168 + _692211;
float* _692206;
_692206 = _453093_681168 + _692205;
float* _692200;
_692200 = _453093_681168 + _692199;
float* _689748;
_689748 = _453093_681168 + _689747;
float* _689742;
_689742 = _453093_681168 + _689741;
float* _689736;
_689736 = _453093_681168 + _689735;
float* _690945;
_690945 = _453093_681168 + _690944;
float* _690939;
_690939 = _453093_681168 + _690938;
float* _690933;
_690933 = _453093_681168 + _690932;
float* _690170;
_690170 = _453093_681168 + _690169;
float* _690164;
_690164 = _453093_681168 + _690163;
float* _690158;
_690158 = _453093_681168 + _690157;
float* _691719;
_691719 = _453093_681168 + _691718;
float* _691713;
_691713 = _453093_681168 + _691712;
float* _691707;
_691707 = _453093_681168 + _691706;
float* _691930;
_691930 = _453093_681168 + _691929;
float* _691924;
_691924 = _453093_681168 + _691923;
float* _691918;
_691918 = _453093_681168 + _691917;
float* _695453;
_695453 = _453093_681168 + _695452;
float* _695447;
_695447 = _453093_681168 + _695446;
float* _695441;
_695441 = _453093_681168 + _695440;
float* _690980;
_690980 = _453093_681168 + _690979;
float* _690974;
_690974 = _453093_681168 + _690973;
float* _690968;
_690968 = _453093_681168 + _690967;
float* _689396;
_689396 = _453093_681168 + _689395;
float* _689390;
_689390 = _453093_681168 + _689389;
float* _689384;
_689384 = _453093_681168 + _689383;
float* _692743;
_692743 = _453093_681168 + _692742;
float* _692737;
_692737 = _453093_681168 + _692736;
float* _692731;
_692731 = _453093_681168 + _692730;
float* _690100;
_690100 = _453093_681168 + _690099;
float* _690094;
_690094 = _453093_681168 + _690093;
float* _690088;
_690088 = _453093_681168 + _690087;
float* _690241;
_690241 = _453093_681168 + _690240;
float* _690235;
_690235 = _453093_681168 + _690234;
float* _690229;
_690229 = _453093_681168 + _690228;
float* _690628;
_690628 = _453093_681168 + _690627;
float* _690622;
_690622 = _453093_681168 + _690621;
float* _690616;
_690616 = _453093_681168 + _690615;
float* _689502;
_689502 = _453093_681168 + _689501;
float* _689496;
_689496 = _453093_681168 + _689495;
float* _689490;
_689490 = _453093_681168 + _689489;
float* _691649;
_691649 = _453093_681168 + _691648;
float* _691643;
_691643 = _453093_681168 + _691642;
float* _691637;
_691637 = _453093_681168 + _691636;
float* _692106;
_692106 = _453093_681168 + _692105;
float* _692100;
_692100 = _453093_681168 + _692099;
float* _692094;
_692094 = _453093_681168 + _692093;
float* _690663;
_690663 = _453093_681168 + _690662;
float* _690657;
_690657 = _453093_681168 + _690656;
float* _690651;
_690651 = _453093_681168 + _690650;
float* _693447;
_693447 = _453093_681168 + _693446;
float* _693441;
_693441 = _453093_681168 + _693440;
float* _693435;
_693435 = _453093_681168 + _693434;
float* _695172;
_695172 = _453093_681168 + _695171;
float* _695166;
_695166 = _453093_681168 + _695165;
float* _695160;
_695160 = _453093_681168 + _695159;
float* _694961;
_694961 = _453093_681168 + _694960;
float* _694955;
_694955 = _453093_681168 + _694954;
float* _694949;
_694949 = _453093_681168 + _694948;
float* _694151;
_694151 = _453093_681168 + _694150;
float* _694145;
_694145 = _453093_681168 + _694144;
float* _694139;
_694139 = _453093_681168 + _694138;
float* _689431;
_689431 = _453093_681168 + _689430;
float* _689425;
_689425 = _453093_681168 + _689424;
float* _689419;
_689419 = _453093_681168 + _689418;
float* _689642;
_689642 = _453093_681168 + _689641;
float* _689636;
_689636 = _453093_681168 + _689635;
float* _689630;
_689630 = _453093_681168 + _689629;
float* _691790;
_691790 = _453093_681168 + _691789;
float* _691784;
_691784 = _453093_681168 + _691783;
float* _691778;
_691778 = _453093_681168 + _691777;
float* _695383;
_695383 = _453093_681168 + _695382;
float* _695377;
_695377 = _453093_681168 + _695376;
float* _695371;
_695371 = _453093_681168 + _695370;
float* _694503;
_694503 = _453093_681168 + _694502;
float* _694497;
_694497 = _453093_681168 + _694496;
float* _694491;
_694491 = _453093_681168 + _694490;
float* _689044;
_689044 = _453093_681168 + _689043;
float* _689038;
_689038 = _453093_681168 + _689037;
float* _689032;
_689032 = _453093_681168 + _689031;
float* _693482;
_693482 = _453093_681168 + _693481;
float* _693476;
_693476 = _453093_681168 + _693475;
float* _693470;
_693470 = _453093_681168 + _693469;
float* _695559;
_695559 = _453093_681168 + _695558;
float* _695553;
_695553 = _453093_681168 + _695552;
float* _695547;
_695547 = _453093_681168 + _695546;
float* _694081;
_694081 = _453093_681168 + _694080;
float* _694075;
_694075 = _453093_681168 + _694074;
float* _694069;
_694069 = _453093_681168 + _694068;
float* _689326;
_689326 = _453093_681168 + _689325;
float* _689320;
_689320 = _453093_681168 + _689319;
float* _689314;
_689314 = _453093_681168 + _689313;
float* _693201;
_693201 = _453093_681168 + _693200;
float* _693195;
_693195 = _453093_681168 + _693194;
float* _693189;
_693189 = _453093_681168 + _693188;
float* _690311;
_690311 = _453093_681168 + _690310;
float* _690305;
_690305 = _453093_681168 + _690304;
float* _690299;
_690299 = _453093_681168 + _690298;
float* _689466;
_689466 = _453093_681168 + _689465;
float* _689460;
_689460 = _453093_681168 + _689459;
float* _689454;
_689454 = _453093_681168 + _689453;
float* _694855;
_694855 = _453093_681168 + _694854;
float* _694849;
_694849 = _453093_681168 + _694848;
float* _694843;
_694843 = _453093_681168 + _694842;
float* _691543;
_691543 = _453093_681168 + _691542;
float* _691537;
_691537 = _453093_681168 + _691536;
float* _691531;
_691531 = _453093_681168 + _691530;
float* _689079;
_689079 = _453093_681168 + _689078;
float* _689073;
_689073 = _453093_681168 + _689072;
float* _689067;
_689067 = _453093_681168 + _689066;
float* _691438;
_691438 = _453093_681168 + _691437;
float* _691432;
_691432 = _453093_681168 + _691431;
float* _691426;
_691426 = _453093_681168 + _691425;
float* _694890;
_694890 = _453093_681168 + _694889;
float* _694884;
_694884 = _453093_681168 + _694883;
float* _694878;
_694878 = _453093_681168 + _694877;
float* _693658;
_693658 = _453093_681168 + _693657;
float* _693652;
_693652 = _453093_681168 + _693651;
float* _693646;
_693646 = _453093_681168 + _693645;
float* _690065;
_690065 = _453093_681168 + _690064;
float* _690059;
_690059 = _453093_681168 + _690058;
float* _690053;
_690053 = _453093_681168 + _690052;
float* _694186;
_694186 = _453093_681168 + _694185;
float* _694180;
_694180 = _453093_681168 + _694179;
float* _694174;
_694174 = _453093_681168 + _694173;
float* _691402;
_691402 = _453093_681168 + _691401;
float* _691396;
_691396 = _453093_681168 + _691395;
float* _691390;
_691390 = _453093_681168 + _691389;
float* _689537;
_689537 = _453093_681168 + _689536;
float* _689531;
_689531 = _453093_681168 + _689530;
float* _689525;
_689525 = _453093_681168 + _689524;
float* _691825;
_691825 = _453093_681168 + _691824;
float* _691819;
_691819 = _453093_681168 + _691818;
float* _691813;
_691813 = _453093_681168 + _691812;
float* _695418;
_695418 = _453093_681168 + _695417;
float* _695412;
_695412 = _453093_681168 + _695411;
float* _695406;
_695406 = _453093_681168 + _695405;
float* _689009;
_689009 = _453093_681168 + _689008;
float* _689003;
_689003 = _453093_681168 + _689002;
float* _688997;
_688997 = _453093_681168 + _688996;
float* _691966;
_691966 = _453093_681168 + _691965;
float* _691960;
_691960 = _453093_681168 + _691959;
float* _691954;
_691954 = _453093_681168 + _691953;
int _689228;
_689228 = 1 + _689227;
int _689756;
_689756 = 1 + _689755;
int _689087;
_689087 = 1 + _689086;
int _690425;
_690425 = 1 + _690424;
int _690707;
_690707 = 1 + _690706;
int _691164;
_691164 = 1 + _691163;
int _692220;
_692220 = 1 + _692219;
int _689967;
_689967 = 1 + _689966;
int _690988;
_690988 = 1 + _690987;
int _691094;
_691094 = 1 + _691093;
int _690812;
_690812 = 1 + _690811;
int _690249;
_690249 = 1 + _690248;
int _692115;
_692115 = 1 + _692114;
int _689932;
_689932 = 1 + _689931;
int _691340;
_691340 = 1 + _691339;
int _689334;
_689334 = 1 + _689333;
int _690003;
_690003 = 1 + _690002;
int _689862;
_689862 = 1 + _689861;
int _691059;
_691059 = 1 + _691058;
int _689791;
_689791 = 1 + _689790;
int _691129;
_691129 = 1 + _691128;
int _688911;
_688911 = 1 + _688910;
int _689897;
_689897 = 1 + _689896;
int _689263;
_689263 = 1 + _689262;
int _691305;
_691305 = 1 + _691304;
int _690495;
_690495 = 1 + _690494;
int _691481;
_691481 = 1 + _691480;
int _691587;
_691587 = 1 + _691586;
int _689158;
_689158 = 1 + _689157;
int _691657;
_691657 = 1 + _691656;
int _691727;
_691727 = 1 + _691726;
int _690460;
_690460 = 1 + _690459;
int _692255;
_692255 = 1 + _692254;
int _692150;
_692150 = 1 + _692149;
int _691023;
_691023 = 1 + _691022;
int _689123;
_689123 = 1 + _689122;
int _689651;
_689651 = 1 + _689650;
int _692009;
_692009 = 1 + _692008;
int _689193;
_689193 = 1 + _689192;
int _689827;
_689827 = 1 + _689826;
int _691235;
_691235 = 1 + _691234;
float* _691578;
_691578 = _453093_681168 + _691577;
float* _691572;
_691572 = _453093_681168 + _691571;
float* _691566;
_691566 = _453093_681168 + _691565;
float* _694292;
_694292 = _453093_681168 + _694291;
float* _694286;
_694286 = _453093_681168 + _694285;
float* _694280;
_694280 = _453093_681168 + _694279;
int _691101;
_691101 = 1 + _691100;
int _689869;
_689869 = 1 + _689868;
int _690256;
_690256 = 1 + _690255;
int _689798;
_689798 = 1 + _689797;
int _689904;
_689904 = 1 + _689903;
int _690502;
_690502 = 1 + _690501;
int _689658;
_689658 = 1 + _689657;
int _691242;
_691242 = 1 + _691241;
int _691488;
_691488 = 1 + _691487;
int _689341;
_689341 = 1 + _689340;
int _689763;
_689763 = 1 + _689762;
int _689939;
_689939 = 1 + _689938;
int _689974;
_689974 = 1 + _689973;
int _691171;
_691171 = 1 + _691170;
int _691347;
_691347 = 1 + _691346;
int _690714;
_690714 = 1 + _690713;
int _688918;
_688918 = 1 + _688917;
int _691312;
_691312 = 1 + _691311;
int _689130;
_689130 = 1 + _689129;
int _691594;
_691594 = 1 + _691593;
int _691734;
_691734 = 1 + _691733;
int _690010;
_690010 = 1 + _690009;
int _689270;
_689270 = 1 + _689269;
int _690819;
_690819 = 1 + _690818;
int _690995;
_690995 = 1 + _690994;
int _691136;
_691136 = 1 + _691135;
int _689165;
_689165 = 1 + _689164;
int _692016;
_692016 = 1 + _692015;
int _692157;
_692157 = 1 + _692156;
int _690467;
_690467 = 1 + _690466;
int _692122;
_692122 = 1 + _692121;
int _689094;
_689094 = 1 + _689093;
int _692227;
_692227 = 1 + _692226;
int _692262;
_692262 = 1 + _692261;
int _691664;
_691664 = 1 + _691663;
int _691066;
_691066 = 1 + _691065;
int _690432;
_690432 = 1 + _690431;
int _691030;
_691030 = 1 + _691029;
int _689834;
_689834 = 1 + _689833;
int _689235;
_689235 = 1 + _689234;
int _689200;
_689200 = 1 + _689199;
float* _694785;
_694785 = _453093_681168 + _694784;
float* _694779;
_694779 = _453093_681168 + _694778;
float* _694773;
_694773 = _453093_681168 + _694772;
float* _694820;
_694820 = _453093_681168 + _694819;
float* _694814;
_694814 = _453093_681168 + _694813;
float* _694808;
_694808 = _453093_681168 + _694807;
float* _689572;
_689572 = _453093_681168 + _689571;
float* _689566;
_689566 = _453093_681168 + _689565;
float* _689560;
_689560 = _453093_681168 + _689559;
float* _693025;
_693025 = _453093_681168 + _693024;
float* _693019;
_693019 = _453093_681168 + _693018;
float* _693013;
_693013 = _453093_681168 + _693012;
float* _688833;
_688833 = _453093_681168 + _688832;
float* _688827;
_688827 = _453093_681168 + _688826;
float* _688821;
_688821 = _453093_681168 + _688820;
float* _694714;
_694714 = _453093_681168 + _694713;
float* _694708;
_694708 = _453093_681168 + _694707;
float* _694702;
_694702 = _453093_681168 + _694701;
float* _693341;
_693341 = _453093_681168 + _693340;
float* _693335;
_693335 = _453093_681168 + _693334;
float* _693329;
_693329 = _453093_681168 + _693328;
float* _695313;
_695313 = _453093_681168 + _695312;
float* _695307;
_695307 = _453093_681168 + _695306;
float* _695301;
_695301 = _453093_681168 + _695300;
float* _690135;
_690135 = _453093_681168 + _690134;
float* _690129;
_690129 = _453093_681168 + _690128;
float* _690123;
_690123 = _453093_681168 + _690122;
float* _689713;
_689713 = _453093_681168 + _689712;
float* _689707;
_689707 = _453093_681168 + _689706;
float* _689701;
_689701 = _453093_681168 + _689700;
float* _690593;
_690593 = _453093_681168 + _690592;
float* _690587;
_690587 = _453093_681168 + _690586;
float* _690581;
_690581 = _453093_681168 + _690580;
float* _690417;
_690417 = _453093_681168 + _690416;
float* _690411;
_690411 = _453093_681168 + _690410;
float* _690405;
_690405 = _453093_681168 + _690404;
float* _695594;
_695594 = _453093_681168 + _695593;
float* _695588;
_695588 = _453093_681168 + _695587;
float* _695582;
_695582 = _453093_681168 + _695581;
float* _690206;
_690206 = _453093_681168 + _690205;
float* _690200;
_690200 = _453093_681168 + _690199;
float* _690194;
_690194 = _453093_681168 + _690193;
float _698531;
_698531 = _698517 + _698530;
int _691613;
_691613 = 1 + _691612;
int _691607;
_691607 = 1 + _691606;
int _691601;
_691601 = 1 + _691600;
int _691683;
_691683 = 1 + _691682;
int _691677;
_691677 = 1 + _691676;
int _691671;
_691671 = 1 + _691670;
float* _691940;
_691940 = _453093_681168 + _691939;
float* _691947;
_691947 = _453093_681168 + _691946;
int _695769;
_695769 = 1 + _695768;
int _695763;
_695763 = 1 + _695762;
int _695757;
_695757 = 1 + _695756;
int _695743;
_695743 = 1 + _695742;
int _695750;
_695750 = 1 + _695749;
int _695734;
_695734 = 1 + _695733;
int _695728;
_695728 = 1 + _695727;
int _695722;
_695722 = 1 + _695721;
int _695708;
_695708 = 1 + _695707;
int _695715;
_695715 = 1 + _695714;
int _695699;
_695699 = 1 + _695698;
int _695693;
_695693 = 1 + _695692;
int _695687;
_695687 = 1 + _695686;
int _695673;
_695673 = 1 + _695672;
int _695680;
_695680 = 1 + _695679;
int _695804;
_695804 = 1 + _695803;
int _695798;
_695798 = 1 + _695797;
int _695792;
_695792 = 1 + _695791;
int _695785;
_695785 = 1 + _695784;
int _695778;
_695778 = 1 + _695777;
float _696536;
_696536 = _696522 + _696535;
float _696423;
_696423 = 4.000000e+00f * _696422;
float* _690391;
_690391 = _453093_681168 + _690390;
float* _690398;
_690398 = _453093_681168 + _690397;
int _693939;
_693939 = 1 + _693938;
int _693933;
_693933 = 1 + _693932;
int _693927;
_693927 = 1 + _693926;
int _693913;
_693913 = 1 + _693912;
int _693920;
_693920 = 1 + _693919;
int _693904;
_693904 = 1 + _693903;
int _693898;
_693898 = 1 + _693897;
int _693892;
_693892 = 1 + _693891;
int _693878;
_693878 = 1 + _693877;
int _693885;
_693885 = 1 + _693884;
int _693974;
_693974 = 1 + _693973;
int _693968;
_693968 = 1 + _693967;
int _693962;
_693962 = 1 + _693961;
int _693948;
_693948 = 1 + _693947;
int _693955;
_693955 = 1 + _693954;
int _694044;
_694044 = 1 + _694043;
int _694038;
_694038 = 1 + _694037;
int _694032;
_694032 = 1 + _694031;
int _694018;
_694018 = 1 + _694017;
int _694025;
_694025 = 1 + _694024;
int _694009;
_694009 = 1 + _694008;
int _694003;
_694003 = 1 + _694002;
int _693997;
_693997 = 1 + _693996;
int _693983;
_693983 = 1 + _693982;
int _693990;
_693990 = 1 + _693989;
int _689923;
_689923 = 1 + _689922;
int _689917;
_689917 = 1 + _689916;
int _689911;
_689911 = 1 + _689910;
int _689888;
_689888 = 1 + _689887;
int _689882;
_689882 = 1 + _689881;
int _689876;
_689876 = 1 + _689875;
int _689853;
_689853 = 1 + _689852;
int _689847;
_689847 = 1 + _689846;
int _689841;
_689841 = 1 + _689840;
int _689993;
_689993 = 1 + _689992;
int _689987;
_689987 = 1 + _689986;
int _689981;
_689981 = 1 + _689980;
int _689958;
_689958 = 1 + _689957;
int _689952;
_689952 = 1 + _689951;
int _689946;
_689946 = 1 + _689945;
float* _690144;
_690144 = _453093_681168 + _690143;
float* _690151;
_690151 = _453093_681168 + _690150;
float* _690180;
_690180 = _453093_681168 + _690179;
float* _690187;
_690187 = _453093_681168 + _690186;
float _698324;
_698324 = _698310 + _698323;
float _696326;
_696326 = 4.000000e+00f * _696325;
float* _691799;
_691799 = _453093_681168 + _691798;
float* _691806;
_691806 = _453093_681168 + _691805;
float _696603;
_696603 = _696589 + _696602;
float _696464;
_696464 = 4.000000e+00f * _696463;
float* _689687;
_689687 = _453093_681168 + _689686;
float* _689694;
_689694 = _453093_681168 + _689693;
int _692812;
_692812 = 1 + _692811;
int _692806;
_692806 = 1 + _692805;
int _692800;
_692800 = 1 + _692799;
int _692786;
_692786 = 1 + _692785;
int _692793;
_692793 = 1 + _692792;
int _692777;
_692777 = 1 + _692776;
int _692771;
_692771 = 1 + _692770;
int _692765;
_692765 = 1 + _692764;
int _692751;
_692751 = 1 + _692750;
int _692758;
_692758 = 1 + _692757;
int _692672;
_692672 = 1 + _692671;
int _692666;
_692666 = 1 + _692665;
int _692660;
_692660 = 1 + _692659;
int _692646;
_692646 = 1 + _692645;
int _692653;
_692653 = 1 + _692652;
int _692707;
_692707 = 1 + _692706;
int _692701;
_692701 = 1 + _692700;
int _692695;
_692695 = 1 + _692694;
int _692681;
_692681 = 1 + _692680;
int _692688;
_692688 = 1 + _692687;
float _697445;
_697445 = _697431 + _697444;
int _695136;
_695136 = 1 + _695135;
int _695130;
_695130 = 1 + _695129;
int _695124;
_695124 = 1 + _695123;
int _695110;
_695110 = 1 + _695109;
int _695117;
_695117 = 1 + _695116;
int _695241;
_695241 = 1 + _695240;
int _695235;
_695235 = 1 + _695234;
int _695229;
_695229 = 1 + _695228;
int _695215;
_695215 = 1 + _695214;
int _695222;
_695222 = 1 + _695221;
int _691261;
_691261 = 1 + _691260;
int _691255;
_691255 = 1 + _691254;
int _691249;
_691249 = 1 + _691248;
int _691366;
_691366 = 1 + _691365;
int _691360;
_691360 = 1 + _691359;
int _691354;
_691354 = 1 + _691353;
int _691331;
_691331 = 1 + _691330;
int _691325;
_691325 = 1 + _691324;
int _691319;
_691319 = 1 + _691318;
float _698133;
_698133 = _698119 + _698132;
int _692531;
_692531 = 1 + _692530;
int _692525;
_692525 = 1 + _692524;
int _692519;
_692519 = 1 + _692518;
int _692505;
_692505 = 1 + _692504;
int _692512;
_692512 = 1 + _692511;
int _692601;
_692601 = 1 + _692600;
int _692595;
_692595 = 1 + _692594;
int _692589;
_692589 = 1 + _692588;
int _692575;
_692575 = 1 + _692574;
int _692582;
_692582 = 1 + _692581;
int _692636;
_692636 = 1 + _692635;
int _692630;
_692630 = 1 + _692629;
int _692624;
_692624 = 1 + _692623;
int _692610;
_692610 = 1 + _692609;
int _692617;
_692617 = 1 + _692616;
float _698285;
_698285 = _698271 + _698284;
float* _689300;
_689300 = _453093_681168 + _689299;
float* _689307;
_689307 = _453093_681168 + _689306;
float* _689370;
_689370 = _453093_681168 + _689369;
float* _689377;
_689377 = _453093_681168 + _689376;
float _697787;
_697787 = 6.000000e+00f * _697786;
float* _690954;
_690954 = _453093_681168 + _690953;
float* _690961;
_690961 = _453093_681168 + _690960;
float* _690285;
_690285 = _453093_681168 + _690284;
float* _690292;
_690292 = _453093_681168 + _690291;
float* _691517;
_691517 = _453093_681168 + _691516;
float* _691524;
_691524 = _453093_681168 + _691523;
float* _688948;
_688948 = _453093_681168 + _688947;
float* _688955;
_688955 = _453093_681168 + _688954;
float* _692045;
_692045 = _453093_681168 + _692044;
float* _692052;
_692052 = _453093_681168 + _692051;
float* _690320;
_690320 = _453093_681168 + _690319;
float* _690327;
_690327 = _453093_681168 + _690326;
float* _691271;
_691271 = _453093_681168 + _691270;
float* _691278;
_691278 = _453093_681168 + _691277;
float _698050;
_698050 = _698036 + _698049;
float* _689440;
_689440 = _453093_681168 + _689439;
float* _689447;
_689447 = _453093_681168 + _689446;
float _697458;
_697458 = 4.000000e+00f * _697457;
float* _691552;
_691552 = _453093_681168 + _691551;
float* _691559;
_691559 = _453093_681168 + _691558;
float _696149;
_696149 = 4.000000e+00f * _696148;
float* _692080;
_692080 = _453093_681168 + _692079;
float* _692087;
_692087 = _453093_681168 + _692086;
float _696190;
_696190 = 4.000000e+00f * _696189;
float* _691412;
_691412 = _453093_681168 + _691411;
float* _691419;
_691419 = _453093_681168 + _691418;
float _698146;
_698146 = 4.000000e+00f * _698145;
float _697084;
_697084 = _697070 + _697083;
int _693728;
_693728 = 1 + _693727;
int _693722;
_693722 = 1 + _693721;
int _693716;
_693716 = 1 + _693715;
int _693702;
_693702 = 1 + _693701;
int _693709;
_693709 = 1 + _693708;
int _693798;
_693798 = 1 + _693797;
int _693792;
_693792 = 1 + _693791;
int _693786;
_693786 = 1 + _693785;
int _693772;
_693772 = 1 + _693771;
int _693779;
_693779 = 1 + _693778;
int _693833;
_693833 = 1 + _693832;
int _693827;
_693827 = 1 + _693826;
int _693821;
_693821 = 1 + _693820;
int _693807;
_693807 = 1 + _693806;
int _693814;
_693814 = 1 + _693813;
int _693763;
_693763 = 1 + _693762;
int _693757;
_693757 = 1 + _693756;
int _693751;
_693751 = 1 + _693750;
int _693737;
_693737 = 1 + _693736;
int _693744;
_693744 = 1 + _693743;
int _693868;
_693868 = 1 + _693867;
int _693862;
_693862 = 1 + _693861;
int _693856;
_693856 = 1 + _693855;
int _693842;
_693842 = 1 + _693841;
int _693849;
_693849 = 1 + _693848;
float _695983;
_695983 = 4.000000e+00f * _695982;
int _695030;
_695030 = 1 + _695029;
int _695024;
_695024 = 1 + _695023;
int _695018;
_695018 = 1 + _695017;
int _695004;
_695004 = 1 + _695003;
int _695011;
_695011 = 1 + _695010;
int _695100;
_695100 = 1 + _695099;
int _695094;
_695094 = 1 + _695093;
int _695088;
_695088 = 1 + _695087;
int _695074;
_695074 = 1 + _695073;
int _695081;
_695081 = 1 + _695080;
int _695065;
_695065 = 1 + _695064;
int _695059;
_695059 = 1 + _695058;
int _695053;
_695053 = 1 + _695052;
int _695039;
_695039 = 1 + _695038;
int _695046;
_695046 = 1 + _695045;
float* _688983;
_688983 = _453093_681168 + _688982;
float* _688990;
_688990 = _453093_681168 + _688989;
float _695943;
_695943 = _695929 + _695942;
float _696893;
_696893 = _696879 + _696892;
float* _691693;
_691693 = _453093_681168 + _691692;
float* _691700;
_691700 = _453093_681168 + _691699;
float* _689581;
_689581 = _453093_681168 + _689580;
float* _689588;
_689588 = _453093_681168 + _689587;
int _689184;
_689184 = 1 + _689183;
int _689178;
_689178 = 1 + _689177;
int _689172;
_689172 = 1 + _689171;
int _689289;
_689289 = 1 + _689288;
int _689283;
_689283 = 1 + _689282;
int _689277;
_689277 = 1 + _689276;
int _689219;
_689219 = 1 + _689218;
int _689213;
_689213 = 1 + _689212;
int _689207;
_689207 = 1 + _689206;
int _689254;
_689254 = 1 + _689253;
int _689248;
_689248 = 1 + _689247;
int _689242;
_689242 = 1 + _689241;
int _689149;
_689149 = 1 + _689148;
int _689143;
_689143 = 1 + _689142;
int _689137;
_689137 = 1 + _689136;
float _698558;
_698558 = 4.000000e+00f * _698557;
float _698406;
_698406 = 6.000000e+00f * _698405;
float _695956;
_695956 = _695943 + _695955;
int _692460;
_692460 = 1 + _692459;
int _692454;
_692454 = 1 + _692453;
int _692448;
_692448 = 1 + _692447;
int _692434;
_692434 = 1 + _692433;
int _692441;
_692441 = 1 + _692440;
int _692425;
_692425 = 1 + _692424;
int _692419;
_692419 = 1 + _692418;
int _692413;
_692413 = 1 + _692412;
int _692399;
_692399 = 1 + _692398;
int _692406;
_692406 = 1 + _692405;
int _692320;
_692320 = 1 + _692319;
int _692314;
_692314 = 1 + _692313;
int _692308;
_692308 = 1 + _692307;
int _692293;
_692293 = 1 + _692292;
int _692301;
_692301 = 1 + _692300;
int _692390;
_692390 = 1 + _692389;
int _692384;
_692384 = 1 + _692383;
int _692378;
_692378 = 1 + _692377;
int _692364;
_692364 = 1 + _692363;
int _692371;
_692371 = 1 + _692370;
int _692355;
_692355 = 1 + _692354;
int _692349;
_692349 = 1 + _692348;
int _692343;
_692343 = 1 + _692342;
int _692329;
_692329 = 1 + _692328;
int _692336;
_692336 = 1 + _692335;
float* _689511;
_689511 = _453093_681168 + _689510;
float* _689518;
_689518 = _453093_681168 + _689517;
float _697306;
_697306 = 6.000000e+00f * _697305;
float _697994;
_697994 = 6.000000e+00f * _697993;
float _697500;
_697500 = _697486 + _697499;
float _697293;
_697293 = _697279 + _697292;
float _698475;
_698475 = 6.000000e+00f * _698474;
float* _691376;
_691376 = _453093_681168 + _691375;
float* _691383;
_691383 = _453093_681168 + _691382;
float* _691764;
_691764 = _453093_681168 + _691763;
float* _691771;
_691771 = _453093_681168 + _691770;
float _696285;
_696285 = 4.000000e+00f * _696284;
float _697942;
_697942 = _697928 + _697941;
float _697240;
_697240 = _697226 + _697239;
int _692246;
_692246 = 1 + _692245;
int _692240;
_692240 = 1 + _692239;
int _692234;
_692234 = 1 + _692233;
int _692281;
_692281 = 1 + _692280;
int _692275;
_692275 = 1 + _692274;
int _692269;
_692269 = 1 + _692268;
int _692176;
_692176 = 1 + _692175;
int _692170;
_692170 = 1 + _692169;
int _692164;
_692164 = 1 + _692163;
int _692141;
_692141 = 1 + _692140;
int _692135;
_692135 = 1 + _692134;
int _692129;
_692129 = 1 + _692128;
float* _691975;
_691975 = _453093_681168 + _691974;
float* _691982;
_691982 = _453093_681168 + _691981;
float _696150;
_696150 = _696136 + _696149;
float _697320;
_697320 = 4.000000e+00f * _697319;
float _698420;
_698420 = 4.000000e+00f * _698419;
float* _689546;
_689546 = _453093_681168 + _689545;
float* _689553;
_689553 = _453093_681168 + _689552;
float _697569;
_697569 = _697555 + _697568;
float _696409;
_696409 = 6.000000e+00f * _696408;
float _696837;
_696837 = 4.000000e+00f * _696836;
float _696163;
_696163 = _696150 + _696162;
float* _692186;
_692186 = _453093_681168 + _692185;
float* _692193;
_692193 = _453093_681168 + _692192;
float _698188;
_698188 = _698174 + _698187;
float _697980;
_697980 = 4.000000e+00f * _697979;
float* _690039;
_690039 = _453093_681168 + _690038;
float* _690046;
_690046 = _453093_681168 + _690045;
float _696672;
_696672 = _696658 + _696671;
float* _689722;
_689722 = _453093_681168 + _689721;
float* _689729;
_689729 = _453093_681168 + _689728;
float* _690919;
_690919 = _453093_681168 + _690918;
float* _690926;
_690926 = _453093_681168 + _690925;
float _698489;
_698489 = 4.000000e+00f * _698488;
float _697856;
_697856 = 6.000000e+00f * _697855;
float* _689476;
_689476 = _453093_681168 + _689475;
float* _689483;
_689483 = _453093_681168 + _689482;
float _698298;
_698298 = _698285 + _698297;
float _698077;
_698077 = 4.000000e+00f * _698076;
float _696906;
_696906 = 4.000000e+00f * _696905;
float* _689616;
_689616 = _453093_681168 + _689615;
float* _689623;
_689623 = _453093_681168 + _689622;
float _698407;
_698407 = _698393 + _698406;
float* _691623;
_691623 = _453093_681168 + _691622;
float* _691630;
_691630 = _453093_681168 + _691629;
float _696960;
_696960 = _696946 + _696959;
float* _690532;
_690532 = _453093_681168 + _690531;
float* _690539;
_690539 = _453093_681168 + _690538;
float _696286;
_696286 = _696272 + _696285;
float* _690356;
_690356 = _453093_681168 + _690355;
float* _690363;
_690363 = _453093_681168 + _690362;
float* _691200;
_691200 = _453093_681168 + _691199;
float* _691207;
_691207 = _453093_681168 + _691206;
float* _689405;
_689405 = _453093_681168 + _689404;
float* _689412;
_689412 = _453093_681168 + _689411;
float* _690074;
_690074 = _453093_681168 + _690073;
float* _690081;
_690081 = _453093_681168 + _690080;
float* _690109;
_690109 = _453093_681168 + _690108;
float* _690116;
_690116 = _453093_681168 + _690115;
float* _689053;
_689053 = _453093_681168 + _689052;
float* _689060;
_689060 = _453093_681168 + _689059;
float* _689018;
_689018 = _453093_681168 + _689017;
float* _689025;
_689025 = _453093_681168 + _689024;
float* _690884;
_690884 = _453093_681168 + _690883;
float* _690891;
_690891 = _453093_681168 + _690890;
float _697719;
_697719 = _697705 + _697718;
float* _690567;
_690567 = _453093_681168 + _690566;
float* _690574;
_690574 = _453093_681168 + _690573;
float* _690637;
_690637 = _453093_681168 + _690636;
float* _690644;
_690644 = _453093_681168 + _690643;
float* _690602;
_690602 = _453093_681168 + _690601;
float* _690609;
_690609 = _453093_681168 + _690608;
float* _690672;
_690672 = _453093_681168 + _690671;
float* _690679;
_690679 = _453093_681168 + _690678;
float* _691447;
_691447 = _453093_681168 + _691446;
float* _691454;
_691454 = _453093_681168 + _691453;
float _697788;
_697788 = _697774 + _697787;
float _697636;
_697636 = _697622 + _697635;
float* _690848;
_690848 = _453093_681168 + _690847;
float* _690855;
_690855 = _453093_681168 + _690854;
float* _690743;
_690743 = _453093_681168 + _690742;
float* _690750;
_690750 = _453093_681168 + _690749;
float* _690778;
_690778 = _453093_681168 + _690777;
float* _690785;
_690785 = _453093_681168 + _690784;
float _696081;
_696081 = _696067 + _696080;
float _696755;
_696755 = _696741 + _696754;
float _697043;
_697043 = _697029 + _697042;
float _697254;
_697254 = _697240 + _697253;
float* _688842;
_688842 = _453093_681168 + _688841;
float* _688849;
_688849 = _453093_681168 + _688848;
float* _688771;
_688771 = _453093_681168 + _688770;
float* _688779;
_688779 = _453093_681168 + _688778;
float* _688877;
_688877 = _453093_681168 + _688876;
float* _688884;
_688884 = _453093_681168 + _688883;
float* _688807;
_688807 = _453093_681168 + _688806;
float* _688814;
_688814 = _453093_681168 + _688813;
float _696824;
_696824 = _696810 + _696823;
float* _690215;
_690215 = _453093_681168 + _690214;
float* _690222;
_690222 = _453093_681168 + _690221;
float* _691904;
_691904 = _453093_681168 + _691903;
float* _691911;
_691911 = _453093_681168 + _691910;
float* _691869;
_691869 = _453093_681168 + _691868;
float* _691876;
_691876 = _453093_681168 + _691875;
float* _691834;
_691834 = _453093_681168 + _691833;
float* _691841;
_691841 = _453093_681168 + _691840;
float _697733;
_697733 = _697719 + _697732;
float _697403;
_697403 = _697390 + _697402;
float _697153;
_697153 = _697139 + _697152;
float _695862;
_695862 = _695848 + _695861;
float _696410;
_696410 = _696396 + _696409;
float _698476;
_698476 = _698462 + _698475;
int _695645;
_695645 = 1 + _695644;
int _692547;
_692547 = 1 + _692546;
int _694518;
_694518 = 1 + _694517;
int _693497;
_693497 = 1 + _693496;
int _694342;
_694342 = 1 + _694341;
int _694061;
_694061 = 1 + _694060;
int _694659;
_694659 = 1 + _694658;
int _694483;
_694483 = 1 + _694482;
int _694765;
_694765 = 1 + _694764;
int _695469;
_695469 = 1 + _695468;
int _695398;
_695398 = 1 + _695397;
int _693181;
_693181 = 1 + _693180;
int _693462;
_693462 = 1 + _693461;
int _694307;
_694307 = 1 + _694306;
int _695257;
_695257 = 1 + _695256;
int _694553;
_694553 = 1 + _694552;
int _693251;
_693251 = 1 + _693250;
int _693673;
_693673 = 1 + _693672;
int _692864;
_692864 = 1 + _692863;
int _693603;
_693603 = 1 + _693602;
int _694870;
_694870 = 1 + _694869;
int _694624;
_694624 = 1 + _694623;
int _693110;
_693110 = 1 + _693109;
int _693216;
_693216 = 1 + _693215;
int _693638;
_693638 = 1 + _693637;
int _694166;
_694166 = 1 + _694165;
int _695433;
_695433 = 1 + _695432;
int _693145;
_693145 = 1 + _693144;
int _695152;
_695152 = 1 + _695151;
int _695328;
_695328 = 1 + _695327;
int _693005;
_693005 = 1 + _693004;
int _695539;
_695539 = 1 + _695538;
int _693533;
_693533 = 1 + _693532;
int _692829;
_692829 = 1 + _692828;
int _694131;
_694131 = 1 + _694130;
int _694237;
_694237 = 1 + _694236;
int _693392;
_693392 = 1 + _693391;
int _694941;
_694941 = 1 + _694940;
int _692934;
_692934 = 1 + _692933;
int _694377;
_694377 = 1 + _694376;
int _693040;
_693040 = 1 + _693039;
int _695363;
_695363 = 1 + _695362;
int _693427;
_693427 = 1 + _693426;
int _695187;
_695187 = 1 + _695186;
int _694835;
_694835 = 1 + _694834;
int _694413;
_694413 = 1 + _694412;
int _694800;
_694800 = 1 + _694799;
int _695574;
_695574 = 1 + _695573;
int _694448;
_694448 = 1 + _694447;
int _692969;
_692969 = 1 + _692968;
int _694694;
_694694 = 1 + _694693;
int _692477;
_692477 = 1 + _692476;
int _693286;
_693286 = 1 + _693285;
int _692723;
_692723 = 1 + _692722;
int _693357;
_693357 = 1 + _693356;
int _693321;
_693321 = 1 + _693320;
int _694201;
_694201 = 1 + _694200;
int _695293;
_695293 = 1 + _695292;
int _693568;
_693568 = 1 + _693567;
int _694976;
_694976 = 1 + _694975;
int _694729;
_694729 = 1 + _694728;
int _693075;
_693075 = 1 + _693074;
int _695504;
_695504 = 1 + _695503;
int _692899;
_692899 = 1 + _692898;
int _694589;
_694589 = 1 + _694588;
int _694096;
_694096 = 1 + _694095;
int _694905;
_694905 = 1 + _694904;
int _695609;
_695609 = 1 + _695608;
int _694272;
_694272 = 1 + _694271;
int _693279;
_693279 = 1 + _693278;
int _694159;
_694159 = 1 + _694158;
int _695356;
_695356 = 1 + _695355;
int _694969;
_694969 = 1 + _694968;
int _694793;
_694793 = 1 + _694792;
int _694758;
_694758 = 1 + _694757;
int _694230;
_694230 = 1 + _694229;
int _695567;
_695567 = 1 + _695566;
int _693209;
_693209 = 1 + _693208;
int _693103;
_693103 = 1 + _693102;
int _694546;
_694546 = 1 + _694545;
int _694617;
_694617 = 1 + _694616;
int _694687;
_694687 = 1 + _694686;
int _692998;
_692998 = 1 + _692997;
int _692962;
_692962 = 1 + _692961;
int _692927;
_692927 = 1 + _692926;
int _693420;
_693420 = 1 + _693419;
int _693490;
_693490 = 1 + _693489;
int _693174;
_693174 = 1 + _693173;
int _695426;
_695426 = 1 + _695425;
int _692716;
_692716 = 1 + _692715;
int _695180;
_695180 = 1 + _695179;
int _694194;
_694194 = 1 + _694193;
int _692892;
_692892 = 1 + _692891;
int _695391;
_695391 = 1 + _695390;
int _694054;
_694054 = 1 + _694053;
int _693314;
_693314 = 1 + _693313;
int _695321;
_695321 = 1 + _695320;
int _694582;
_694582 = 1 + _694581;
int _693068;
_693068 = 1 + _693067;
int _693350;
_693350 = 1 + _693349;
int _694265;
_694265 = 1 + _694264;
int _692822;
_692822 = 1 + _692821;
int _693138;
_693138 = 1 + _693137;
int _695638;
_695638 = 1 + _695637;
int _694511;
_694511 = 1 + _694510;
int _692470;
_692470 = 1 + _692469;
int _694828;
_694828 = 1 + _694827;
int _695286;
_695286 = 1 + _695285;
int _694300;
_694300 = 1 + _694299;
int _693526;
_693526 = 1 + _693525;
int _694898;
_694898 = 1 + _694897;
int _694124;
_694124 = 1 + _694123;
int _695145;
_695145 = 1 + _695144;
int _693596;
_693596 = 1 + _693595;
int _693244;
_693244 = 1 + _693243;
int _694476;
_694476 = 1 + _694475;
int _694722;
_694722 = 1 + _694721;
int _695462;
_695462 = 1 + _695461;
int _693033;
_693033 = 1 + _693032;
int _695250;
_695250 = 1 + _695249;
int _694652;
_694652 = 1 + _694651;
int _694335;
_694335 = 1 + _694334;
int _693455;
_693455 = 1 + _693454;
int _695602;
_695602 = 1 + _695601;
int _693631;
_693631 = 1 + _693630;
int _692857;
_692857 = 1 + _692856;
int _694441;
_694441 = 1 + _694440;
int _693666;
_693666 = 1 + _693665;
int _693561;
_693561 = 1 + _693560;
int _694089;
_694089 = 1 + _694088;
int _693385;
_693385 = 1 + _693384;
int _692540;
_692540 = 1 + _692539;
int _695532;
_695532 = 1 + _695531;
int _695497;
_695497 = 1 + _695496;
int _694934;
_694934 = 1 + _694933;
int _694370;
_694370 = 1 + _694369;
int _694406;
_694406 = 1 + _694405;
int _694863;
_694863 = 1 + _694862;
float* _689229;
_689229 = _453093_681168 + _689228;
float* _689757;
_689757 = _453093_681168 + _689756;
float* _689088;
_689088 = _453093_681168 + _689087;
float* _690426;
_690426 = _453093_681168 + _690425;
float* _690708;
_690708 = _453093_681168 + _690707;
float* _691165;
_691165 = _453093_681168 + _691164;
float* _692221;
_692221 = _453093_681168 + _692220;
float* _689968;
_689968 = _453093_681168 + _689967;
float* _690989;
_690989 = _453093_681168 + _690988;
float* _691095;
_691095 = _453093_681168 + _691094;
float* _690813;
_690813 = _453093_681168 + _690812;
float* _690250;
_690250 = _453093_681168 + _690249;
float* _692116;
_692116 = _453093_681168 + _692115;
float* _689933;
_689933 = _453093_681168 + _689932;
float* _691341;
_691341 = _453093_681168 + _691340;
float* _689335;
_689335 = _453093_681168 + _689334;
float* _690004;
_690004 = _453093_681168 + _690003;
float* _689863;
_689863 = _453093_681168 + _689862;
float* _691060;
_691060 = _453093_681168 + _691059;
float* _689792;
_689792 = _453093_681168 + _689791;
float* _691130;
_691130 = _453093_681168 + _691129;
float* _688912;
_688912 = _453093_681168 + _688911;
float* _689898;
_689898 = _453093_681168 + _689897;
float* _689264;
_689264 = _453093_681168 + _689263;
float* _691306;
_691306 = _453093_681168 + _691305;
float* _690496;
_690496 = _453093_681168 + _690495;
float* _691482;
_691482 = _453093_681168 + _691481;
float* _691588;
_691588 = _453093_681168 + _691587;
float* _689159;
_689159 = _453093_681168 + _689158;
float* _691658;
_691658 = _453093_681168 + _691657;
float* _691728;
_691728 = _453093_681168 + _691727;
float* _690461;
_690461 = _453093_681168 + _690460;
float* _692256;
_692256 = _453093_681168 + _692255;
float* _692151;
_692151 = _453093_681168 + _692150;
float* _691024;
_691024 = _453093_681168 + _691023;
float* _689124;
_689124 = _453093_681168 + _689123;
float* _689652;
_689652 = _453093_681168 + _689651;
float* _692010;
_692010 = _453093_681168 + _692009;
float* _689194;
_689194 = _453093_681168 + _689193;
float* _689828;
_689828 = _453093_681168 + _689827;
float* _691236;
_691236 = _453093_681168 + _691235;
float* _691102;
_691102 = _453093_681168 + _691101;
float* _689870;
_689870 = _453093_681168 + _689869;
float* _690257;
_690257 = _453093_681168 + _690256;
float* _689799;
_689799 = _453093_681168 + _689798;
float* _689905;
_689905 = _453093_681168 + _689904;
float* _690503;
_690503 = _453093_681168 + _690502;
float* _689659;
_689659 = _453093_681168 + _689658;
float* _691243;
_691243 = _453093_681168 + _691242;
float* _691489;
_691489 = _453093_681168 + _691488;
float* _689342;
_689342 = _453093_681168 + _689341;
float* _689764;
_689764 = _453093_681168 + _689763;
float* _689940;
_689940 = _453093_681168 + _689939;
float* _689975;
_689975 = _453093_681168 + _689974;
float* _691172;
_691172 = _453093_681168 + _691171;
float* _691348;
_691348 = _453093_681168 + _691347;
float* _690715;
_690715 = _453093_681168 + _690714;
float* _688919;
_688919 = _453093_681168 + _688918;
float* _691313;
_691313 = _453093_681168 + _691312;
float* _689131;
_689131 = _453093_681168 + _689130;
float* _691595;
_691595 = _453093_681168 + _691594;
float* _691735;
_691735 = _453093_681168 + _691734;
float* _690011;
_690011 = _453093_681168 + _690010;
float* _689271;
_689271 = _453093_681168 + _689270;
float* _690820;
_690820 = _453093_681168 + _690819;
float* _690996;
_690996 = _453093_681168 + _690995;
float* _691137;
_691137 = _453093_681168 + _691136;
float* _689166;
_689166 = _453093_681168 + _689165;
float* _692017;
_692017 = _453093_681168 + _692016;
float* _692158;
_692158 = _453093_681168 + _692157;
float* _690468;
_690468 = _453093_681168 + _690467;
float* _692123;
_692123 = _453093_681168 + _692122;
float* _689095;
_689095 = _453093_681168 + _689094;
float* _692228;
_692228 = _453093_681168 + _692227;
float* _692263;
_692263 = _453093_681168 + _692262;
float* _691665;
_691665 = _453093_681168 + _691664;
float* _691067;
_691067 = _453093_681168 + _691066;
float* _690433;
_690433 = _453093_681168 + _690432;
float* _691031;
_691031 = _453093_681168 + _691030;
float* _689835;
_689835 = _453093_681168 + _689834;
float* _689236;
_689236 = _453093_681168 + _689235;
float* _689201;
_689201 = _453093_681168 + _689200;
float _698545;
_698545 = _698531 + _698544;
float* _691614;
_691614 = _453093_681168 + _691613;
float* _691608;
_691608 = _453093_681168 + _691607;
float* _691602;
_691602 = _453093_681168 + _691601;
float* _691684;
_691684 = _453093_681168 + _691683;
float* _691678;
_691678 = _453093_681168 + _691677;
float* _691672;
_691672 = _453093_681168 + _691671;
float* _695770;
_695770 = _453093_681168 + _695769;
float* _695764;
_695764 = _453093_681168 + _695763;
float* _695758;
_695758 = _453093_681168 + _695757;
float* _695744;
_695744 = _453093_681168 + _695743;
float* _695751;
_695751 = _453093_681168 + _695750;
float* _695735;
_695735 = _453093_681168 + _695734;
float* _695729;
_695729 = _453093_681168 + _695728;
float* _695723;
_695723 = _453093_681168 + _695722;
float* _695709;
_695709 = _453093_681168 + _695708;
float* _695716;
_695716 = _453093_681168 + _695715;
float* _695700;
_695700 = _453093_681168 + _695699;
float* _695694;
_695694 = _453093_681168 + _695693;
float* _695688;
_695688 = _453093_681168 + _695687;
float* _695674;
_695674 = _453093_681168 + _695673;
float* _695681;
_695681 = _453093_681168 + _695680;
float* _695805;
_695805 = _453093_681168 + _695804;
float* _695799;
_695799 = _453093_681168 + _695798;
float* _695793;
_695793 = _453093_681168 + _695792;
float* _695786;
_695786 = _453093_681168 + _695785;
float* _695779;
_695779 = _453093_681168 + _695778;
float _696550;
_696550 = _696536 + _696549;
float _696424;
_696424 = _696410 + _696423;
float* _693940;
_693940 = _453093_681168 + _693939;
float* _693934;
_693934 = _453093_681168 + _693933;
float* _693928;
_693928 = _453093_681168 + _693927;
float* _693914;
_693914 = _453093_681168 + _693913;
float* _693921;
_693921 = _453093_681168 + _693920;
float* _693905;
_693905 = _453093_681168 + _693904;
float* _693899;
_693899 = _453093_681168 + _693898;
float* _693893;
_693893 = _453093_681168 + _693892;
float* _693879;
_693879 = _453093_681168 + _693878;
float* _693886;
_693886 = _453093_681168 + _693885;
float* _693975;
_693975 = _453093_681168 + _693974;
float* _693969;
_693969 = _453093_681168 + _693968;
float* _693963;
_693963 = _453093_681168 + _693962;
float* _693949;
_693949 = _453093_681168 + _693948;
float* _693956;
_693956 = _453093_681168 + _693955;
float* _694045;
_694045 = _453093_681168 + _694044;
float* _694039;
_694039 = _453093_681168 + _694038;
float* _694033;
_694033 = _453093_681168 + _694032;
float* _694019;
_694019 = _453093_681168 + _694018;
float* _694026;
_694026 = _453093_681168 + _694025;
float* _694010;
_694010 = _453093_681168 + _694009;
float* _694004;
_694004 = _453093_681168 + _694003;
float* _693998;
_693998 = _453093_681168 + _693997;
float* _693984;
_693984 = _453093_681168 + _693983;
float* _693991;
_693991 = _453093_681168 + _693990;
float* _689924;
_689924 = _453093_681168 + _689923;
float* _689918;
_689918 = _453093_681168 + _689917;
float* _689912;
_689912 = _453093_681168 + _689911;
float* _689889;
_689889 = _453093_681168 + _689888;
float* _689883;
_689883 = _453093_681168 + _689882;
float* _689877;
_689877 = _453093_681168 + _689876;
float* _689854;
_689854 = _453093_681168 + _689853;
float* _689848;
_689848 = _453093_681168 + _689847;
float* _689842;
_689842 = _453093_681168 + _689841;
float* _689994;
_689994 = _453093_681168 + _689993;
float* _689988;
_689988 = _453093_681168 + _689987;
float* _689982;
_689982 = _453093_681168 + _689981;
float* _689959;
_689959 = _453093_681168 + _689958;
float* _689953;
_689953 = _453093_681168 + _689952;
float* _689947;
_689947 = _453093_681168 + _689946;
float _698338;
_698338 = _698324 + _698337;
float _696327;
_696327 = _696313 + _696326;
float _696617;
_696617 = _696603 + _696616;
float _696465;
_696465 = _696451 + _696464;
float* _692813;
_692813 = _453093_681168 + _692812;
float* _692807;
_692807 = _453093_681168 + _692806;
float* _692801;
_692801 = _453093_681168 + _692800;
float* _692787;
_692787 = _453093_681168 + _692786;
float* _692794;
_692794 = _453093_681168 + _692793;
float* _692778;
_692778 = _453093_681168 + _692777;
float* _692772;
_692772 = _453093_681168 + _692771;
float* _692766;
_692766 = _453093_681168 + _692765;
float* _692752;
_692752 = _453093_681168 + _692751;
float* _692759;
_692759 = _453093_681168 + _692758;
float* _692673;
_692673 = _453093_681168 + _692672;
float* _692667;
_692667 = _453093_681168 + _692666;
float* _692661;
_692661 = _453093_681168 + _692660;
float* _692647;
_692647 = _453093_681168 + _692646;
float* _692654;
_692654 = _453093_681168 + _692653;
float* _692708;
_692708 = _453093_681168 + _692707;
float* _692702;
_692702 = _453093_681168 + _692701;
float* _692696;
_692696 = _453093_681168 + _692695;
float* _692682;
_692682 = _453093_681168 + _692681;
float* _692689;
_692689 = _453093_681168 + _692688;
float _697459;
_697459 = _697445 + _697458;
float* _695137;
_695137 = _453093_681168 + _695136;
float* _695131;
_695131 = _453093_681168 + _695130;
float* _695125;
_695125 = _453093_681168 + _695124;
float* _695111;
_695111 = _453093_681168 + _695110;
float* _695118;
_695118 = _453093_681168 + _695117;
float* _695242;
_695242 = _453093_681168 + _695241;
float* _695236;
_695236 = _453093_681168 + _695235;
float* _695230;
_695230 = _453093_681168 + _695229;
float* _695216;
_695216 = _453093_681168 + _695215;
float* _695223;
_695223 = _453093_681168 + _695222;
float* _691262;
_691262 = _453093_681168 + _691261;
float* _691256;
_691256 = _453093_681168 + _691255;
float* _691250;
_691250 = _453093_681168 + _691249;
float* _691367;
_691367 = _453093_681168 + _691366;
float* _691361;
_691361 = _453093_681168 + _691360;
float* _691355;
_691355 = _453093_681168 + _691354;
float* _691332;
_691332 = _453093_681168 + _691331;
float* _691326;
_691326 = _453093_681168 + _691325;
float* _691320;
_691320 = _453093_681168 + _691319;
float _698147;
_698147 = _698133 + _698146;
float* _692532;
_692532 = _453093_681168 + _692531;
float* _692526;
_692526 = _453093_681168 + _692525;
float* _692520;
_692520 = _453093_681168 + _692519;
float* _692506;
_692506 = _453093_681168 + _692505;
float* _692513;
_692513 = _453093_681168 + _692512;
float* _692602;
_692602 = _453093_681168 + _692601;
float* _692596;
_692596 = _453093_681168 + _692595;
float* _692590;
_692590 = _453093_681168 + _692589;
float* _692576;
_692576 = _453093_681168 + _692575;
float* _692583;
_692583 = _453093_681168 + _692582;
float* _692637;
_692637 = _453093_681168 + _692636;
float* _692631;
_692631 = _453093_681168 + _692630;
float* _692625;
_692625 = _453093_681168 + _692624;
float* _692611;
_692611 = _453093_681168 + _692610;
float* _692618;
_692618 = _453093_681168 + _692617;
float _698064;
_698064 = _698050 + _698063;
float _696191;
_696191 = _696177 + _696190;
float _697098;
_697098 = _697084 + _697097;
float* _693729;
_693729 = _453093_681168 + _693728;
float* _693723;
_693723 = _453093_681168 + _693722;
float* _693717;
_693717 = _453093_681168 + _693716;
float* _693703;
_693703 = _453093_681168 + _693702;
float* _693710;
_693710 = _453093_681168 + _693709;
float* _693799;
_693799 = _453093_681168 + _693798;
float* _693793;
_693793 = _453093_681168 + _693792;
float* _693787;
_693787 = _453093_681168 + _693786;
float* _693773;
_693773 = _453093_681168 + _693772;
float* _693780;
_693780 = _453093_681168 + _693779;
float* _693834;
_693834 = _453093_681168 + _693833;
float* _693828;
_693828 = _453093_681168 + _693827;
float* _693822;
_693822 = _453093_681168 + _693821;
float* _693808;
_693808 = _453093_681168 + _693807;
float* _693815;
_693815 = _453093_681168 + _693814;
float* _693764;
_693764 = _453093_681168 + _693763;
float* _693758;
_693758 = _453093_681168 + _693757;
float* _693752;
_693752 = _453093_681168 + _693751;
float* _693738;
_693738 = _453093_681168 + _693737;
float* _693745;
_693745 = _453093_681168 + _693744;
float* _693869;
_693869 = _453093_681168 + _693868;
float* _693863;
_693863 = _453093_681168 + _693862;
float* _693857;
_693857 = _453093_681168 + _693856;
float* _693843;
_693843 = _453093_681168 + _693842;
float* _693850;
_693850 = _453093_681168 + _693849;
float _695984;
_695984 = _695970 + _695983;
float* _695031;
_695031 = _453093_681168 + _695030;
float* _695025;
_695025 = _453093_681168 + _695024;
float* _695019;
_695019 = _453093_681168 + _695018;
float* _695005;
_695005 = _453093_681168 + _695004;
float* _695012;
_695012 = _453093_681168 + _695011;
float* _695101;
_695101 = _453093_681168 + _695100;
float* _695095;
_695095 = _453093_681168 + _695094;
float* _695089;
_695089 = _453093_681168 + _695088;
float* _695075;
_695075 = _453093_681168 + _695074;
float* _695082;
_695082 = _453093_681168 + _695081;
float* _695066;
_695066 = _453093_681168 + _695065;
float* _695060;
_695060 = _453093_681168 + _695059;
float* _695054;
_695054 = _453093_681168 + _695053;
float* _695040;
_695040 = _453093_681168 + _695039;
float* _695047;
_695047 = _453093_681168 + _695046;
float _696907;
_696907 = _696893 + _696906;
float* _689185;
_689185 = _453093_681168 + _689184;
float* _689179;
_689179 = _453093_681168 + _689178;
float* _689173;
_689173 = _453093_681168 + _689172;
float* _689290;
_689290 = _453093_681168 + _689289;
float* _689284;
_689284 = _453093_681168 + _689283;
float* _689278;
_689278 = _453093_681168 + _689277;
float* _689220;
_689220 = _453093_681168 + _689219;
float* _689214;
_689214 = _453093_681168 + _689213;
float* _689208;
_689208 = _453093_681168 + _689207;
float* _689255;
_689255 = _453093_681168 + _689254;
float* _689249;
_689249 = _453093_681168 + _689248;
float* _689243;
_689243 = _453093_681168 + _689242;
float* _689150;
_689150 = _453093_681168 + _689149;
float* _689144;
_689144 = _453093_681168 + _689143;
float* _689138;
_689138 = _453093_681168 + _689137;
float _698559;
_698559 = _698545 + _698558;
float _695957;
_695957 = 4.000000e+00f * _695956;
float* _692461;
_692461 = _453093_681168 + _692460;
float* _692455;
_692455 = _453093_681168 + _692454;
float* _692449;
_692449 = _453093_681168 + _692448;
float* _692435;
_692435 = _453093_681168 + _692434;
float* _692442;
_692442 = _453093_681168 + _692441;
float* _692426;
_692426 = _453093_681168 + _692425;
float* _692420;
_692420 = _453093_681168 + _692419;
float* _692414;
_692414 = _453093_681168 + _692413;
float* _692400;
_692400 = _453093_681168 + _692399;
float* _692407;
_692407 = _453093_681168 + _692406;
float* _692321;
_692321 = _453093_681168 + _692320;
float* _692315;
_692315 = _453093_681168 + _692314;
float* _692309;
_692309 = _453093_681168 + _692308;
float* _692294;
_692294 = _453093_681168 + _692293;
float* _692302;
_692302 = _453093_681168 + _692301;
float* _692391;
_692391 = _453093_681168 + _692390;
float* _692385;
_692385 = _453093_681168 + _692384;
float* _692379;
_692379 = _453093_681168 + _692378;
float* _692365;
_692365 = _453093_681168 + _692364;
float* _692372;
_692372 = _453093_681168 + _692371;
float* _692356;
_692356 = _453093_681168 + _692355;
float* _692350;
_692350 = _453093_681168 + _692349;
float* _692344;
_692344 = _453093_681168 + _692343;
float* _692330;
_692330 = _453093_681168 + _692329;
float* _692337;
_692337 = _453093_681168 + _692336;
float _697307;
_697307 = _697293 + _697306;
float _697514;
_697514 = _697500 + _697513;
float _697955;
_697955 = _697942 + _697954;
float* _692247;
_692247 = _453093_681168 + _692246;
float* _692241;
_692241 = _453093_681168 + _692240;
float* _692235;
_692235 = _453093_681168 + _692234;
float* _692282;
_692282 = _453093_681168 + _692281;
float* _692276;
_692276 = _453093_681168 + _692275;
float* _692270;
_692270 = _453093_681168 + _692269;
float* _692177;
_692177 = _453093_681168 + _692176;
float* _692171;
_692171 = _453093_681168 + _692170;
float* _692165;
_692165 = _453093_681168 + _692164;
float* _692142;
_692142 = _453093_681168 + _692141;
float* _692136;
_692136 = _453093_681168 + _692135;
float* _692130;
_692130 = _453093_681168 + _692129;
float _697321;
_697321 = _697307 + _697320;
float _698421;
_698421 = _698407 + _698420;
float _697583;
_697583 = _697569 + _697582;
float _696838;
_696838 = _696824 + _696837;
float _698202;
_698202 = _698188 + _698201;
float _697981;
_697981 = _697967 + _697980;
float _696686;
_696686 = _696672 + _696685;
float _698490;
_698490 = _698476 + _698489;
float _697857;
_697857 = _697843 + _697856;
float _698078;
_698078 = _698064 + _698077;
float _696974;
_696974 = _696960 + _696973;
float _696299;
_696299 = _696286 + _696298;
float _697802;
_697802 = _697788 + _697801;
float _697650;
_697650 = _697636 + _697649;
float _696094;
_696094 = _696081 + _696093;
float _696769;
_696769 = _696755 + _696768;
float _697056;
_697056 = _697043 + _697055;
float _697267;
_697267 = _697254 + _697266;
float _688772;
_688772 = *_688771;
float _697746;
_697746 = _697733 + _697745;
float _697404;
_697404 = 6.000000e+00f * _697403;
float _697167;
_697167 = _697153 + _697166;
float _695876;
_695876 = _695862 + _695875;
float* _695646;
_695646 = _453093_681168 + _695645;
float* _692548;
_692548 = _453093_681168 + _692547;
float* _694519;
_694519 = _453093_681168 + _694518;
float* _693498;
_693498 = _453093_681168 + _693497;
float* _694343;
_694343 = _453093_681168 + _694342;
float* _694062;
_694062 = _453093_681168 + _694061;
float* _694660;
_694660 = _453093_681168 + _694659;
float* _694484;
_694484 = _453093_681168 + _694483;
float* _694766;
_694766 = _453093_681168 + _694765;
float* _695470;
_695470 = _453093_681168 + _695469;
float* _695399;
_695399 = _453093_681168 + _695398;
float* _693182;
_693182 = _453093_681168 + _693181;
float* _693463;
_693463 = _453093_681168 + _693462;
float* _694308;
_694308 = _453093_681168 + _694307;
float* _695258;
_695258 = _453093_681168 + _695257;
float* _694554;
_694554 = _453093_681168 + _694553;
float* _693252;
_693252 = _453093_681168 + _693251;
float* _693674;
_693674 = _453093_681168 + _693673;
float* _692865;
_692865 = _453093_681168 + _692864;
float* _693604;
_693604 = _453093_681168 + _693603;
float* _694871;
_694871 = _453093_681168 + _694870;
float* _694625;
_694625 = _453093_681168 + _694624;
float* _693111;
_693111 = _453093_681168 + _693110;
float* _693217;
_693217 = _453093_681168 + _693216;
float* _693639;
_693639 = _453093_681168 + _693638;
float* _694167;
_694167 = _453093_681168 + _694166;
float* _695434;
_695434 = _453093_681168 + _695433;
float* _693146;
_693146 = _453093_681168 + _693145;
float* _695153;
_695153 = _453093_681168 + _695152;
float* _695329;
_695329 = _453093_681168 + _695328;
float* _693006;
_693006 = _453093_681168 + _693005;
float* _695540;
_695540 = _453093_681168 + _695539;
float* _693534;
_693534 = _453093_681168 + _693533;
float* _692830;
_692830 = _453093_681168 + _692829;
float* _694132;
_694132 = _453093_681168 + _694131;
float* _694238;
_694238 = _453093_681168 + _694237;
float* _693393;
_693393 = _453093_681168 + _693392;
float* _694942;
_694942 = _453093_681168 + _694941;
float* _692935;
_692935 = _453093_681168 + _692934;
float* _694378;
_694378 = _453093_681168 + _694377;
float* _693041;
_693041 = _453093_681168 + _693040;
float* _695364;
_695364 = _453093_681168 + _695363;
float* _693428;
_693428 = _453093_681168 + _693427;
float* _695188;
_695188 = _453093_681168 + _695187;
float* _694836;
_694836 = _453093_681168 + _694835;
float* _694414;
_694414 = _453093_681168 + _694413;
float* _694801;
_694801 = _453093_681168 + _694800;
float* _695575;
_695575 = _453093_681168 + _695574;
float* _694449;
_694449 = _453093_681168 + _694448;
float* _692970;
_692970 = _453093_681168 + _692969;
float* _694695;
_694695 = _453093_681168 + _694694;
float* _692478;
_692478 = _453093_681168 + _692477;
float* _693287;
_693287 = _453093_681168 + _693286;
float* _692724;
_692724 = _453093_681168 + _692723;
float* _693358;
_693358 = _453093_681168 + _693357;
float* _693322;
_693322 = _453093_681168 + _693321;
float* _694202;
_694202 = _453093_681168 + _694201;
float* _695294;
_695294 = _453093_681168 + _695293;
float* _693569;
_693569 = _453093_681168 + _693568;
float* _694977;
_694977 = _453093_681168 + _694976;
float* _694730;
_694730 = _453093_681168 + _694729;
float* _693076;
_693076 = _453093_681168 + _693075;
float* _695505;
_695505 = _453093_681168 + _695504;
float* _692900;
_692900 = _453093_681168 + _692899;
float* _694590;
_694590 = _453093_681168 + _694589;
float* _694097;
_694097 = _453093_681168 + _694096;
float* _694906;
_694906 = _453093_681168 + _694905;
float* _695610;
_695610 = _453093_681168 + _695609;
float* _694273;
_694273 = _453093_681168 + _694272;
float* _693280;
_693280 = _453093_681168 + _693279;
float* _694160;
_694160 = _453093_681168 + _694159;
float* _695357;
_695357 = _453093_681168 + _695356;
float* _694970;
_694970 = _453093_681168 + _694969;
float* _694794;
_694794 = _453093_681168 + _694793;
float* _694759;
_694759 = _453093_681168 + _694758;
float* _694231;
_694231 = _453093_681168 + _694230;
float* _695568;
_695568 = _453093_681168 + _695567;
float* _693210;
_693210 = _453093_681168 + _693209;
float* _693104;
_693104 = _453093_681168 + _693103;
float* _694547;
_694547 = _453093_681168 + _694546;
float* _694618;
_694618 = _453093_681168 + _694617;
float* _694688;
_694688 = _453093_681168 + _694687;
float* _692999;
_692999 = _453093_681168 + _692998;
float* _692963;
_692963 = _453093_681168 + _692962;
float* _692928;
_692928 = _453093_681168 + _692927;
float* _693421;
_693421 = _453093_681168 + _693420;
float* _693491;
_693491 = _453093_681168 + _693490;
float* _693175;
_693175 = _453093_681168 + _693174;
float* _695427;
_695427 = _453093_681168 + _695426;
float* _692717;
_692717 = _453093_681168 + _692716;
float* _695181;
_695181 = _453093_681168 + _695180;
float* _694195;
_694195 = _453093_681168 + _694194;
float* _692893;
_692893 = _453093_681168 + _692892;
float* _695392;
_695392 = _453093_681168 + _695391;
float* _694055;
_694055 = _453093_681168 + _694054;
float* _693315;
_693315 = _453093_681168 + _693314;
float* _695322;
_695322 = _453093_681168 + _695321;
float* _694583;
_694583 = _453093_681168 + _694582;
float* _693069;
_693069 = _453093_681168 + _693068;
float* _693351;
_693351 = _453093_681168 + _693350;
float* _694266;
_694266 = _453093_681168 + _694265;
float* _692823;
_692823 = _453093_681168 + _692822;
float* _693139;
_693139 = _453093_681168 + _693138;
float* _695639;
_695639 = _453093_681168 + _695638;
float* _694512;
_694512 = _453093_681168 + _694511;
float* _692471;
_692471 = _453093_681168 + _692470;
float* _694829;
_694829 = _453093_681168 + _694828;
float* _695287;
_695287 = _453093_681168 + _695286;
float* _694301;
_694301 = _453093_681168 + _694300;
float* _693527;
_693527 = _453093_681168 + _693526;
float* _694899;
_694899 = _453093_681168 + _694898;
float* _694125;
_694125 = _453093_681168 + _694124;
float* _695146;
_695146 = _453093_681168 + _695145;
float* _693597;
_693597 = _453093_681168 + _693596;
float* _693245;
_693245 = _453093_681168 + _693244;
float* _694477;
_694477 = _453093_681168 + _694476;
float* _694723;
_694723 = _453093_681168 + _694722;
float* _695463;
_695463 = _453093_681168 + _695462;
float* _693034;
_693034 = _453093_681168 + _693033;
float* _695251;
_695251 = _453093_681168 + _695250;
float* _694653;
_694653 = _453093_681168 + _694652;
float* _694336;
_694336 = _453093_681168 + _694335;
float* _693456;
_693456 = _453093_681168 + _693455;
float* _695603;
_695603 = _453093_681168 + _695602;
float* _693632;
_693632 = _453093_681168 + _693631;
float* _692858;
_692858 = _453093_681168 + _692857;
float* _694442;
_694442 = _453093_681168 + _694441;
float* _693667;
_693667 = _453093_681168 + _693666;
float* _693562;
_693562 = _453093_681168 + _693561;
float* _694090;
_694090 = _453093_681168 + _694089;
float* _693386;
_693386 = _453093_681168 + _693385;
float* _692541;
_692541 = _453093_681168 + _692540;
float* _695533;
_695533 = _453093_681168 + _695532;
float* _695498;
_695498 = _453093_681168 + _695497;
float* _694935;
_694935 = _453093_681168 + _694934;
float* _694371;
_694371 = _453093_681168 + _694370;
float* _694407;
_694407 = _453093_681168 + _694406;
float* _694864;
_694864 = _453093_681168 + _694863;
float _696564;
_696564 = _696550 + _696563;
float _696437;
_696437 = _696424 + _696436;
float _698352;
_698352 = _698338 + _698351;
float _696341;
_696341 = _696327 + _696340;
float _696631;
_696631 = _696617 + _696630;
float _696479;
_696479 = _696465 + _696478;
float _697472;
_697472 = _697459 + _697471;
float _698160;
_698160 = _698147 + _698159;
float _696205;
_696205 = _696191 + _696204;
float _697112;
_697112 = _697098 + _697111;
float _695998;
_695998 = _695984 + _695997;
float _696920;
_696920 = _696907 + _696919;
float _698572;
_698572 = _698559 + _698571;
float _697528;
_697528 = _697514 + _697527;
float _697334;
_697334 = _697321 + _697333;
float _698434;
_698434 = _698421 + _698433;
float _697597;
_697597 = _697583 + _697596;
float _696851;
_696851 = _696838 + _696850;
float _698216;
_698216 = _698202 + _698215;
float _697995;
_697995 = _697981 + _697994;
float _696700;
_696700 = _696686 + _696699;
float _698503;
_698503 = _698490 + _698502;
float _697871;
_697871 = _697857 + _697870;
float _698091;
_698091 = _698078 + _698090;
float _696987;
_696987 = _696974 + _696986;
float _696300;
_696300 = 4.000000e+00f * _696299;
float _697815;
_697815 = _697802 + _697814;
float _697664;
_697664 = _697650 + _697663;
float _696095;
_696095 = 4.000000e+00f * _696094;
float _696782;
_696782 = _696769 + _696781;
float _697057;
_697057 = 6.000000e+00f * _697056;
float _698583;
_698583 = _688772;
float _697747;
_697747 = 6.000000e+00f * _697746;
float _697181;
_697181 = _697167 + _697180;
float _695889;
_695889 = _695876 + _695888;
float _696577;
_696577 = _696564 + _696576;
float _696438;
_696438 = 4.000000e+00f * _696437;
float _698365;
_698365 = _698352 + _698364;
float _696355;
_696355 = _696341 + _696354;
float _696644;
_696644 = _696631 + _696643;
float _696493;
_696493 = _696479 + _696492;
float _697473;
_697473 = 4.000000e+00f * _697472;
float _698161;
_698161 = 4.000000e+00f * _698160;
float _696219;
_696219 = _696205 + _696218;
float _697125;
_697125 = _697112 + _697124;
float _696012;
_696012 = _695998 + _696011;
float _697541;
_697541 = _697528 + _697540;
float _697335;
_697335 = 4.000000e+00f * _697334;
float _698435;
_698435 = 6.000000e+00f * _698434;
float _697610;
_697610 = _697597 + _697609;
float _698229;
_698229 = _698216 + _698228;
float _698009;
_698009 = _697995 + _698008;
float _696713;
_696713 = _696700 + _696712;
float _698504;
_698504 = 4.000000e+00f * _698503;
float _697884;
_697884 = _697871 + _697883;
float _698092;
_698092 = 6.000000e+00f * _698091;
float _696988;
_696988 = 4.000000e+00f * _696987;
float _697816;
_697816 = 4.000000e+00f * _697815;
float _697677;
_697677 = _697664 + _697676;
float _696783;
_696783 = 4.000000e+00f * _696782;
float _688780;
_688780 = *_688779;
float _697194;
_697194 = _697181 + _697193;
float _695958;
_695958 = _695889 + _695957;
float _698366;
_698366 = 4.000000e+00f * _698365;
float _696368;
_696368 = _696355 + _696367;
float _696645;
_696645 = 4.000000e+00f * _696644;
float _696506;
_696506 = _696493 + _696505;
float _696232;
_696232 = _696219 + _696231;
float _697126;
_697126 = 4.000000e+00f * _697125;
float _696025;
_696025 = _696012 + _696024;
float _697336;
_697336 = _697267 + _697335;
float _698022;
_698022 = _698009 + _698021;
float _696714;
_696714 = 6.000000e+00f * _696713;
float _696989;
_696989 = _696920 + _696988;
float _697678;
_697678 = 4.000000e+00f * _697677;
float _698584;
_698584 = _688780;
float _698367;
_698367 = _698298 + _698366;
float _696369;
_696369 = 6.000000e+00f * _696368;
float _696646;
_696646 = _696577 + _696645;
float _696301;
_696301 = _696232 + _696300;
float _696026;
_696026 = 6.000000e+00f * _696025;
float _697405;
_697405 = _697336 + _697404;
float _698023;
_698023 = 4.000000e+00f * _698022;
float _696715;
_696715 = _696646 + _696714;
float _697058;
_697058 = _696989 + _697057;
float _697679;
_697679 = _697610 + _697678;
float _698585;
_698585 = 4.000000e+00f * _698584;
float _688787;
_688787 = *_688786;
float _698436;
_698436 = _698367 + _698435;
float _696370;
_696370 = _696301 + _696369;
float _696027;
_696027 = _695958 + _696026;
float _697474;
_697474 = _697405 + _697473;
float _698024;
_698024 = _697955 + _698023;
float _696784;
_696784 = _696715 + _696783;
float _697127;
_697127 = _697058 + _697126;
float _697748;
_697748 = _697679 + _697747;
float _698586;
_698586 = _698583 + _698585;
float _698587;
_698587 = _688787;
float _698505;
_698505 = _698436 + _698504;
float _696439;
_696439 = _696370 + _696438;
float _696096;
_696096 = _696027 + _696095;
float _697542;
_697542 = _697474 + _697541;
float _698093;
_698093 = _698024 + _698092;
float _696852;
_696852 = _696784 + _696851;
float _697195;
_697195 = _697127 + _697194;
float _697817;
_697817 = _697748 + _697816;
float _698588;
_698588 = 6.000000e+00f * _698587;
float _688793;
_688793 = *_688792;
float _698573;
_698573 = _698505 + _698572;
float _696507;
_696507 = _696439 + _696506;
float _696164;
_696164 = _696096 + _696163;
float _697543;
_697543 = _695820 * _697542;
float _698162;
_698162 = _698093 + _698161;
float _696853;
_696853 = _695820 * _696852;
float _697196;
_697196 = xf_695819 * _697195;
float _697885;
_697885 = _697817 + _697884;
float _698589;
_698589 = _698586 + _698588;
float _698590;
_698590 = _688793;
float _698574;
_698574 = xf_695819 * _698573;
float _696508;
_696508 = xf_695819 * _696507;
float _696165;
_696165 = _695820 * _696164;
float _698230;
_698230 = _698162 + _698229;
float _697197;
_697197 = _696853 + _697196;
float _697886;
_697886 = xf_695819 * _697885;
float _698591;
_698591 = 4.000000e+00f * _698590;
float _688799;
_688799 = *_688798;
float _696509;
_696509 = _696165 + _696508;
float _698231;
_698231 = _695820 * _698230;
float _697198;
_697198 = yf_695815 * _697197;
float _697887;
_697887 = _697543 + _697886;
float _698592;
_698592 = _698589 + _698591;
float _698593;
_698593 = _688799;
float _696510;
_696510 = _695816 * _696509;
float _698575;
_698575 = _698231 + _698574;
float _697199;
_697199 = _696510 + _697198;
float _697888;
_697888 = _695816 * _697887;
float _698594;
_698594 = _698592 + _698593;
float _688808;
_688808 = *_688807;
float _698576;
_698576 = yf_695815 * _698575;
float _697200;
_697200 = _695811 * _697199;
float _698577;
_698577 = _697888 + _698576;
float _698595;
_698595 = _688808;
float _698578;
_698578 = zf_695810 * _698577;
float _688815;
_688815 = *_688814;
float _698579;
_698579 = _697200 + _698578;
float _698596;
_698596 = _688815;
float _698597;
_698597 = 4.000000e+00f * _698596;
float _688822;
_688822 = *_688821;
float _698598;
_698598 = _698595 + _698597;
float _698599;
_698599 = _688822;
float _698600;
_698600 = 6.000000e+00f * _698599;
float _688828;
_688828 = *_688827;
float _698601;
_698601 = _698598 + _698600;
float _698602;
_698602 = _688828;
float _698603;
_698603 = 4.000000e+00f * _698602;
float _688834;
_688834 = *_688833;
float _698604;
_698604 = _698601 + _698603;
float _698605;
_698605 = _688834;
float _698606;
_698606 = _698604 + _698605;
float _688843;
_688843 = *_688842;
float _698607;
_698607 = 4.000000e+00f * _698606;
float _698609;
_698609 = _688843;
float _698608;
_698608 = _698594 + _698607;
float _688850;
_688850 = *_688849;
float _698610;
_698610 = _688850;
float _698611;
_698611 = 4.000000e+00f * _698610;
float _688857;
_688857 = *_688856;
float _698612;
_698612 = _698609 + _698611;
float _698613;
_698613 = _688857;
float _698614;
_698614 = 6.000000e+00f * _698613;
float _688863;
_688863 = *_688862;
float _698615;
_698615 = _698612 + _698614;
float _698616;
_698616 = _688863;
float _698617;
_698617 = 4.000000e+00f * _698616;
float _688869;
_688869 = *_688868;
float _698618;
_698618 = _698615 + _698617;
float _698619;
_698619 = _688869;
float _698620;
_698620 = _698618 + _698619;
float _688878;
_688878 = *_688877;
float _698621;
_698621 = 6.000000e+00f * _698620;
float _698623;
_698623 = _688878;
float _698622;
_698622 = _698608 + _698621;
float _688885;
_688885 = *_688884;
float _698624;
_698624 = _688885;
float _698625;
_698625 = 4.000000e+00f * _698624;
float _688892;
_688892 = *_688891;
float _698626;
_698626 = _698623 + _698625;
float _698627;
_698627 = _688892;
float _698628;
_698628 = 6.000000e+00f * _698627;
float _688898;
_688898 = *_688897;
float _698629;
_698629 = _698626 + _698628;
float _698630;
_698630 = _688898;
float _698631;
_698631 = 4.000000e+00f * _698630;
float _688904;
_688904 = *_688903;
float _698632;
_698632 = _698629 + _698631;
float _698633;
_698633 = _688904;
float _698634;
_698634 = _698632 + _698633;
float _688913;
_688913 = *_688912;
float _698635;
_698635 = 4.000000e+00f * _698634;
float _698637;
_698637 = _688913;
float _698636;
_698636 = _698622 + _698635;
float _688920;
_688920 = *_688919;
float _698638;
_698638 = _688920;
float _698639;
_698639 = 4.000000e+00f * _698638;
float _688927;
_688927 = *_688926;
float _698640;
_698640 = _698637 + _698639;
float _698641;
_698641 = _688927;
float _698642;
_698642 = 6.000000e+00f * _698641;
float _688933;
_688933 = *_688932;
float _698643;
_698643 = _698640 + _698642;
float _698644;
_698644 = _688933;
float _698645;
_698645 = 4.000000e+00f * _698644;
float _688939;
_688939 = *_688938;
float _698646;
_698646 = _698643 + _698645;
float _698647;
_698647 = _688939;
float _698648;
_698648 = _698646 + _698647;
float _688949;
_688949 = *_688948;
float _698649;
_698649 = _698636 + _698648;
float _698650;
_698650 = _688949;
float _688956;
_688956 = *_688955;
float _698651;
_698651 = _688956;
float _698652;
_698652 = 4.000000e+00f * _698651;
float _688963;
_688963 = *_688962;
float _698653;
_698653 = _698650 + _698652;
float _698654;
_698654 = _688963;
float _698655;
_698655 = 6.000000e+00f * _698654;
float _688969;
_688969 = *_688968;
float _698656;
_698656 = _698653 + _698655;
float _698657;
_698657 = _688969;
float _698658;
_698658 = 4.000000e+00f * _698657;
float _688975;
_688975 = *_688974;
float _698659;
_698659 = _698656 + _698658;
float _698660;
_698660 = _688975;
float _698661;
_698661 = _698659 + _698660;
float _688984;
_688984 = *_688983;
float _698662;
_698662 = _688984;
float _688991;
_688991 = *_688990;
float _698663;
_698663 = _688991;
float _698664;
_698664 = 4.000000e+00f * _698663;
float _688998;
_688998 = *_688997;
float _698665;
_698665 = _698662 + _698664;
float _698666;
_698666 = _688998;
float _698667;
_698667 = 6.000000e+00f * _698666;
float _689004;
_689004 = *_689003;
float _698668;
_698668 = _698665 + _698667;
float _698669;
_698669 = _689004;
float _698670;
_698670 = 4.000000e+00f * _698669;
float _689010;
_689010 = *_689009;
float _698671;
_698671 = _698668 + _698670;
float _698672;
_698672 = _689010;
float _698673;
_698673 = _698671 + _698672;
float _689019;
_689019 = *_689018;
float _698674;
_698674 = 4.000000e+00f * _698673;
float _698676;
_698676 = _689019;
float _698675;
_698675 = _698661 + _698674;
float _689026;
_689026 = *_689025;
float _698677;
_698677 = _689026;
float _698678;
_698678 = 4.000000e+00f * _698677;
float _689033;
_689033 = *_689032;
float _698679;
_698679 = _698676 + _698678;
float _698680;
_698680 = _689033;
float _698681;
_698681 = 6.000000e+00f * _698680;
float _689039;
_689039 = *_689038;
float _698682;
_698682 = _698679 + _698681;
float _698683;
_698683 = _689039;
float _698684;
_698684 = 4.000000e+00f * _698683;
float _689045;
_689045 = *_689044;
float _698685;
_698685 = _698682 + _698684;
float _698686;
_698686 = _689045;
float _698687;
_698687 = _698685 + _698686;
float _689054;
_689054 = *_689053;
float _698688;
_698688 = 6.000000e+00f * _698687;
float _698690;
_698690 = _689054;
float _698689;
_698689 = _698675 + _698688;
float _689061;
_689061 = *_689060;
float _698691;
_698691 = _689061;
float _698692;
_698692 = 4.000000e+00f * _698691;
float _689068;
_689068 = *_689067;
float _698693;
_698693 = _698690 + _698692;
float _698694;
_698694 = _689068;
float _698695;
_698695 = 6.000000e+00f * _698694;
float _689074;
_689074 = *_689073;
float _698696;
_698696 = _698693 + _698695;
float _698697;
_698697 = _689074;
float _698698;
_698698 = 4.000000e+00f * _698697;
float _689080;
_689080 = *_689079;
float _698699;
_698699 = _698696 + _698698;
float _698700;
_698700 = _689080;
float _698701;
_698701 = _698699 + _698700;
float _689089;
_689089 = *_689088;
float _698702;
_698702 = 4.000000e+00f * _698701;
float _698704;
_698704 = _689089;
float _698703;
_698703 = _698689 + _698702;
float _689096;
_689096 = *_689095;
float _698705;
_698705 = _689096;
float _698706;
_698706 = 4.000000e+00f * _698705;
float _689103;
_689103 = *_689102;
float _698707;
_698707 = _698704 + _698706;
float _698708;
_698708 = _689103;
float _698709;
_698709 = 6.000000e+00f * _698708;
float _689109;
_689109 = *_689108;
float _698710;
_698710 = _698707 + _698709;
float _698711;
_698711 = _689109;
float _698712;
_698712 = 4.000000e+00f * _698711;
float _689115;
_689115 = *_689114;
float _698713;
_698713 = _698710 + _698712;
float _698714;
_698714 = _689115;
float _698715;
_698715 = _698713 + _698714;
float _689125;
_689125 = *_689124;
float _698716;
_698716 = _698703 + _698715;
float _698719;
_698719 = _689125;
float _698717;
_698717 = 4.000000e+00f * _698716;
float _689132;
_689132 = *_689131;
float _698718;
_698718 = _698649 + _698717;
float _698720;
_698720 = _689132;
float _698721;
_698721 = 4.000000e+00f * _698720;
float _689139;
_689139 = *_689138;
float _698722;
_698722 = _698719 + _698721;
float _698723;
_698723 = _689139;
float _698724;
_698724 = 6.000000e+00f * _698723;
float _689145;
_689145 = *_689144;
float _698725;
_698725 = _698722 + _698724;
float _698726;
_698726 = _689145;
float _698727;
_698727 = 4.000000e+00f * _698726;
float _689151;
_689151 = *_689150;
float _698728;
_698728 = _698725 + _698727;
float _698729;
_698729 = _689151;
float _698730;
_698730 = _698728 + _698729;
float _689160;
_689160 = *_689159;
float _698731;
_698731 = _689160;
float _689167;
_689167 = *_689166;
float _698732;
_698732 = _689167;
float _698733;
_698733 = 4.000000e+00f * _698732;
float _689174;
_689174 = *_689173;
float _698734;
_698734 = _698731 + _698733;
float _698735;
_698735 = _689174;
float _698736;
_698736 = 6.000000e+00f * _698735;
float _689180;
_689180 = *_689179;
float _698737;
_698737 = _698734 + _698736;
float _698738;
_698738 = _689180;
float _698739;
_698739 = 4.000000e+00f * _698738;
float _689186;
_689186 = *_689185;
float _698740;
_698740 = _698737 + _698739;
float _698741;
_698741 = _689186;
float _698742;
_698742 = _698740 + _698741;
float _689195;
_689195 = *_689194;
float _698743;
_698743 = 4.000000e+00f * _698742;
float _698745;
_698745 = _689195;
float _698744;
_698744 = _698730 + _698743;
float _689202;
_689202 = *_689201;
float _698746;
_698746 = _689202;
float _698747;
_698747 = 4.000000e+00f * _698746;
float _689209;
_689209 = *_689208;
float _698748;
_698748 = _698745 + _698747;
float _698749;
_698749 = _689209;
float _698750;
_698750 = 6.000000e+00f * _698749;
float _689215;
_689215 = *_689214;
float _698751;
_698751 = _698748 + _698750;
float _698752;
_698752 = _689215;
float _698753;
_698753 = 4.000000e+00f * _698752;
float _689221;
_689221 = *_689220;
float _698754;
_698754 = _698751 + _698753;
float _698755;
_698755 = _689221;
float _698756;
_698756 = _698754 + _698755;
float _689230;
_689230 = *_689229;
float _698757;
_698757 = 6.000000e+00f * _698756;
float _698759;
_698759 = _689230;
float _698758;
_698758 = _698744 + _698757;
float _689237;
_689237 = *_689236;
float _698760;
_698760 = _689237;
float _698761;
_698761 = 4.000000e+00f * _698760;
float _689244;
_689244 = *_689243;
float _698762;
_698762 = _698759 + _698761;
float _698763;
_698763 = _689244;
float _698764;
_698764 = 6.000000e+00f * _698763;
float _689250;
_689250 = *_689249;
float _698765;
_698765 = _698762 + _698764;
float _698766;
_698766 = _689250;
float _698767;
_698767 = 4.000000e+00f * _698766;
float _689256;
_689256 = *_689255;
float _698768;
_698768 = _698765 + _698767;
float _698769;
_698769 = _689256;
float _698770;
_698770 = _698768 + _698769;
float _689265;
_689265 = *_689264;
float _698771;
_698771 = 4.000000e+00f * _698770;
float _698773;
_698773 = _689265;
float _698772;
_698772 = _698758 + _698771;
float _689272;
_689272 = *_689271;
float _698774;
_698774 = _689272;
float _698775;
_698775 = 4.000000e+00f * _698774;
float _689279;
_689279 = *_689278;
float _698776;
_698776 = _698773 + _698775;
float _698777;
_698777 = _689279;
float _698778;
_698778 = 6.000000e+00f * _698777;
float _689285;
_689285 = *_689284;
float _698779;
_698779 = _698776 + _698778;
float _698780;
_698780 = _689285;
float _698781;
_698781 = 4.000000e+00f * _698780;
float _689291;
_689291 = *_689290;
float _698782;
_698782 = _698779 + _698781;
float _698783;
_698783 = _689291;
float _698784;
_698784 = _698782 + _698783;
float _689301;
_689301 = *_689300;
float _698785;
_698785 = _698772 + _698784;
float _698788;
_698788 = _689301;
float _698786;
_698786 = 6.000000e+00f * _698785;
float _689308;
_689308 = *_689307;
float _698787;
_698787 = _698718 + _698786;
float _698789;
_698789 = _689308;
float _698790;
_698790 = 4.000000e+00f * _698789;
float _689315;
_689315 = *_689314;
float _698791;
_698791 = _698788 + _698790;
float _698792;
_698792 = _689315;
float _698793;
_698793 = 6.000000e+00f * _698792;
float _689321;
_689321 = *_689320;
float _698794;
_698794 = _698791 + _698793;
float _698795;
_698795 = _689321;
float _698796;
_698796 = 4.000000e+00f * _698795;
float _689327;
_689327 = *_689326;
float _698797;
_698797 = _698794 + _698796;
float _698798;
_698798 = _689327;
float _698799;
_698799 = _698797 + _698798;
float _689336;
_689336 = *_689335;
float _698800;
_698800 = _689336;
float _689343;
_689343 = *_689342;
float _698801;
_698801 = _689343;
float _698802;
_698802 = 4.000000e+00f * _698801;
float _689350;
_689350 = *_689349;
float _698803;
_698803 = _698800 + _698802;
float _698804;
_698804 = _689350;
float _698805;
_698805 = 6.000000e+00f * _698804;
float _689356;
_689356 = *_689355;
float _698806;
_698806 = _698803 + _698805;
float _698807;
_698807 = _689356;
float _698808;
_698808 = 4.000000e+00f * _698807;
float _689362;
_689362 = *_689361;
float _698809;
_698809 = _698806 + _698808;
float _698810;
_698810 = _689362;
float _698811;
_698811 = _698809 + _698810;
float _689371;
_689371 = *_689370;
float _698812;
_698812 = 4.000000e+00f * _698811;
float _698814;
_698814 = _689371;
float _698813;
_698813 = _698799 + _698812;
float _689378;
_689378 = *_689377;
float _698815;
_698815 = _689378;
float _698816;
_698816 = 4.000000e+00f * _698815;
float _689385;
_689385 = *_689384;
float _698817;
_698817 = _698814 + _698816;
float _698818;
_698818 = _689385;
float _698819;
_698819 = 6.000000e+00f * _698818;
float _689391;
_689391 = *_689390;
float _698820;
_698820 = _698817 + _698819;
float _698821;
_698821 = _689391;
float _698822;
_698822 = 4.000000e+00f * _698821;
float _689397;
_689397 = *_689396;
float _698823;
_698823 = _698820 + _698822;
float _698824;
_698824 = _689397;
float _698825;
_698825 = _698823 + _698824;
float _689406;
_689406 = *_689405;
float _698826;
_698826 = 6.000000e+00f * _698825;
float _698828;
_698828 = _689406;
float _698827;
_698827 = _698813 + _698826;
float _689413;
_689413 = *_689412;
float _698829;
_698829 = _689413;
float _698830;
_698830 = 4.000000e+00f * _698829;
float _689420;
_689420 = *_689419;
float _698831;
_698831 = _698828 + _698830;
float _698832;
_698832 = _689420;
float _698833;
_698833 = 6.000000e+00f * _698832;
float _689426;
_689426 = *_689425;
float _698834;
_698834 = _698831 + _698833;
float _698835;
_698835 = _689426;
float _698836;
_698836 = 4.000000e+00f * _698835;
float _689432;
_689432 = *_689431;
float _698837;
_698837 = _698834 + _698836;
float _698838;
_698838 = _689432;
float _698839;
_698839 = _698837 + _698838;
float _689441;
_689441 = *_689440;
float _698840;
_698840 = 4.000000e+00f * _698839;
float _698842;
_698842 = _689441;
float _698841;
_698841 = _698827 + _698840;
float _689448;
_689448 = *_689447;
float _698843;
_698843 = _689448;
float _698844;
_698844 = 4.000000e+00f * _698843;
float _689455;
_689455 = *_689454;
float _698845;
_698845 = _698842 + _698844;
float _698846;
_698846 = _689455;
float _698847;
_698847 = 6.000000e+00f * _698846;
float _689461;
_689461 = *_689460;
float _698848;
_698848 = _698845 + _698847;
float _698849;
_698849 = _689461;
float _698850;
_698850 = 4.000000e+00f * _698849;
float _689467;
_689467 = *_689466;
float _698851;
_698851 = _698848 + _698850;
float _698852;
_698852 = _689467;
float _698853;
_698853 = _698851 + _698852;
float _689477;
_689477 = *_689476;
float _698854;
_698854 = _698841 + _698853;
float _698857;
_698857 = _689477;
float _698855;
_698855 = 4.000000e+00f * _698854;
float _689484;
_689484 = *_689483;
float _698856;
_698856 = _698787 + _698855;
float _698858;
_698858 = _689484;
float _698859;
_698859 = 4.000000e+00f * _698858;
float _689491;
_689491 = *_689490;
float _698860;
_698860 = _698857 + _698859;
float _698861;
_698861 = _689491;
float _698862;
_698862 = 6.000000e+00f * _698861;
float _689497;
_689497 = *_689496;
float _698863;
_698863 = _698860 + _698862;
float _698864;
_698864 = _689497;
float _698865;
_698865 = 4.000000e+00f * _698864;
float _689503;
_689503 = *_689502;
float _698866;
_698866 = _698863 + _698865;
float _698867;
_698867 = _689503;
float _698868;
_698868 = _698866 + _698867;
float _689512;
_689512 = *_689511;
float _698869;
_698869 = _689512;
float _689519;
_689519 = *_689518;
float _698870;
_698870 = _689519;
float _698871;
_698871 = 4.000000e+00f * _698870;
float _689526;
_689526 = *_689525;
float _698872;
_698872 = _698869 + _698871;
float _698873;
_698873 = _689526;
float _698874;
_698874 = 6.000000e+00f * _698873;
float _689532;
_689532 = *_689531;
float _698875;
_698875 = _698872 + _698874;
float _698876;
_698876 = _689532;
float _698877;
_698877 = 4.000000e+00f * _698876;
float _689538;
_689538 = *_689537;
float _698878;
_698878 = _698875 + _698877;
float _698879;
_698879 = _689538;
float _698880;
_698880 = _698878 + _698879;
float _689547;
_689547 = *_689546;
float _698881;
_698881 = 4.000000e+00f * _698880;
float _698883;
_698883 = _689547;
float _698882;
_698882 = _698868 + _698881;
float _689554;
_689554 = *_689553;
float _698884;
_698884 = _689554;
float _698885;
_698885 = 4.000000e+00f * _698884;
float _689561;
_689561 = *_689560;
float _698886;
_698886 = _698883 + _698885;
float _698887;
_698887 = _689561;
float _698888;
_698888 = 6.000000e+00f * _698887;
float _689567;
_689567 = *_689566;
float _698889;
_698889 = _698886 + _698888;
float _698890;
_698890 = _689567;
float _698891;
_698891 = 4.000000e+00f * _698890;
float _689573;
_689573 = *_689572;
float _698892;
_698892 = _698889 + _698891;
float _698893;
_698893 = _689573;
float _698894;
_698894 = _698892 + _698893;
float _689582;
_689582 = *_689581;
float _698895;
_698895 = 6.000000e+00f * _698894;
float _698897;
_698897 = _689582;
float _698896;
_698896 = _698882 + _698895;
float _689589;
_689589 = *_689588;
float _698898;
_698898 = _689589;
float _698899;
_698899 = 4.000000e+00f * _698898;
float _689596;
_689596 = *_689595;
float _698900;
_698900 = _698897 + _698899;
float _698901;
_698901 = _689596;
float _698902;
_698902 = 6.000000e+00f * _698901;
float _689602;
_689602 = *_689601;
float _698903;
_698903 = _698900 + _698902;
float _698904;
_698904 = _689602;
float _698905;
_698905 = 4.000000e+00f * _698904;
float _689608;
_689608 = *_689607;
float _698906;
_698906 = _698903 + _698905;
float _698907;
_698907 = _689608;
float _698908;
_698908 = _698906 + _698907;
float _689617;
_689617 = *_689616;
float _698909;
_698909 = 4.000000e+00f * _698908;
float _698911;
_698911 = _689617;
float _698910;
_698910 = _698896 + _698909;
float _689624;
_689624 = *_689623;
float _698912;
_698912 = _689624;
float _698913;
_698913 = 4.000000e+00f * _698912;
float _689631;
_689631 = *_689630;
float _698914;
_698914 = _698911 + _698913;
float _698915;
_698915 = _689631;
float _698916;
_698916 = 6.000000e+00f * _698915;
float _689637;
_689637 = *_689636;
float _698917;
_698917 = _698914 + _698916;
float _698918;
_698918 = _689637;
float _698919;
_698919 = 4.000000e+00f * _698918;
float _689643;
_689643 = *_689642;
float _698920;
_698920 = _698917 + _698919;
float _698921;
_698921 = _689643;
float _698922;
_698922 = _698920 + _698921;
float _689653;
_689653 = *_689652;
float _698923;
_698923 = _698910 + _698922;
float _698926;
_698926 = _689653;
float _698924;
_698924 = _698856 + _698923;
float _689660;
_689660 = *_689659;
float _698925;
_698925 = _695820 * _698924;
float _698927;
_698927 = _689660;
float _698928;
_698928 = 4.000000e+00f * _698927;
float _689667;
_689667 = *_689666;
float _698929;
_698929 = _698926 + _698928;
float _698930;
_698930 = _689667;
float _698931;
_698931 = 6.000000e+00f * _698930;
float _689673;
_689673 = *_689672;
float _698932;
_698932 = _698929 + _698931;
float _698933;
_698933 = _689673;
float _698934;
_698934 = 4.000000e+00f * _698933;
float _689679;
_689679 = *_689678;
float _698935;
_698935 = _698932 + _698934;
float _698936;
_698936 = _689679;
float _698937;
_698937 = _698935 + _698936;
float _689688;
_689688 = *_689687;
float _698938;
_698938 = _689688;
float _689695;
_689695 = *_689694;
float _698939;
_698939 = _689695;
float _698940;
_698940 = 4.000000e+00f * _698939;
float _689702;
_689702 = *_689701;
float _698941;
_698941 = _698938 + _698940;
float _698942;
_698942 = _689702;
float _698943;
_698943 = 6.000000e+00f * _698942;
float _689708;
_689708 = *_689707;
float _698944;
_698944 = _698941 + _698943;
float _698945;
_698945 = _689708;
float _698946;
_698946 = 4.000000e+00f * _698945;
float _689714;
_689714 = *_689713;
float _698947;
_698947 = _698944 + _698946;
float _698948;
_698948 = _689714;
float _698949;
_698949 = _698947 + _698948;
float _689723;
_689723 = *_689722;
float _698950;
_698950 = 4.000000e+00f * _698949;
float _698952;
_698952 = _689723;
float _698951;
_698951 = _698937 + _698950;
float _689730;
_689730 = *_689729;
float _698953;
_698953 = _689730;
float _698954;
_698954 = 4.000000e+00f * _698953;
float _689737;
_689737 = *_689736;
float _698955;
_698955 = _698952 + _698954;
float _698956;
_698956 = _689737;
float _698957;
_698957 = 6.000000e+00f * _698956;
float _689743;
_689743 = *_689742;
float _698958;
_698958 = _698955 + _698957;
float _698959;
_698959 = _689743;
float _698960;
_698960 = 4.000000e+00f * _698959;
float _689749;
_689749 = *_689748;
float _698961;
_698961 = _698958 + _698960;
float _698962;
_698962 = _689749;
float _698963;
_698963 = _698961 + _698962;
float _689758;
_689758 = *_689757;
float _698964;
_698964 = 6.000000e+00f * _698963;
float _698966;
_698966 = _689758;
float _698965;
_698965 = _698951 + _698964;
float _689765;
_689765 = *_689764;
float _698967;
_698967 = _689765;
float _698968;
_698968 = 4.000000e+00f * _698967;
float _689772;
_689772 = *_689771;
float _698969;
_698969 = _698966 + _698968;
float _698970;
_698970 = _689772;
float _698971;
_698971 = 6.000000e+00f * _698970;
float _689778;
_689778 = *_689777;
float _698972;
_698972 = _698969 + _698971;
float _698973;
_698973 = _689778;
float _698974;
_698974 = 4.000000e+00f * _698973;
float _689784;
_689784 = *_689783;
float _698975;
_698975 = _698972 + _698974;
float _698976;
_698976 = _689784;
float _698977;
_698977 = _698975 + _698976;
float _689793;
_689793 = *_689792;
float _698978;
_698978 = 4.000000e+00f * _698977;
float _698980;
_698980 = _689793;
float _698979;
_698979 = _698965 + _698978;
float _689800;
_689800 = *_689799;
float _698981;
_698981 = _689800;
float _698982;
_698982 = 4.000000e+00f * _698981;
float _689807;
_689807 = *_689806;
float _698983;
_698983 = _698980 + _698982;
float _698984;
_698984 = _689807;
float _698985;
_698985 = 6.000000e+00f * _698984;
float _689813;
_689813 = *_689812;
float _698986;
_698986 = _698983 + _698985;
float _698987;
_698987 = _689813;
float _698988;
_698988 = 4.000000e+00f * _698987;
float _689819;
_689819 = *_689818;
float _698989;
_698989 = _698986 + _698988;
float _698990;
_698990 = _689819;
float _698991;
_698991 = _698989 + _698990;
float _689829;
_689829 = *_689828;
float _698992;
_698992 = _698979 + _698991;
float _698993;
_698993 = _689829;
float _689836;
_689836 = *_689835;
float _698994;
_698994 = _689836;
float _698995;
_698995 = 4.000000e+00f * _698994;
float _689843;
_689843 = *_689842;
float _698996;
_698996 = _698993 + _698995;
float _698997;
_698997 = _689843;
float _698998;
_698998 = 6.000000e+00f * _698997;
float _689849;
_689849 = *_689848;
float _698999;
_698999 = _698996 + _698998;
float _699000;
_699000 = _689849;
float _699001;
_699001 = 4.000000e+00f * _699000;
float _689855;
_689855 = *_689854;
float _699002;
_699002 = _698999 + _699001;
float _699003;
_699003 = _689855;
float _699004;
_699004 = _699002 + _699003;
float _689864;
_689864 = *_689863;
float _699005;
_699005 = _689864;
float _689871;
_689871 = *_689870;
float _699006;
_699006 = _689871;
float _699007;
_699007 = 4.000000e+00f * _699006;
float _689878;
_689878 = *_689877;
float _699008;
_699008 = _699005 + _699007;
float _699009;
_699009 = _689878;
float _699010;
_699010 = 6.000000e+00f * _699009;
float _689884;
_689884 = *_689883;
float _699011;
_699011 = _699008 + _699010;
float _699012;
_699012 = _689884;
float _699013;
_699013 = 4.000000e+00f * _699012;
float _689890;
_689890 = *_689889;
float _699014;
_699014 = _699011 + _699013;
float _699015;
_699015 = _689890;
float _699016;
_699016 = _699014 + _699015;
float _689899;
_689899 = *_689898;
float _699017;
_699017 = 4.000000e+00f * _699016;
float _699019;
_699019 = _689899;
float _699018;
_699018 = _699004 + _699017;
float _689906;
_689906 = *_689905;
float _699020;
_699020 = _689906;
float _699021;
_699021 = 4.000000e+00f * _699020;
float _689913;
_689913 = *_689912;
float _699022;
_699022 = _699019 + _699021;
float _699023;
_699023 = _689913;
float _699024;
_699024 = 6.000000e+00f * _699023;
float _689919;
_689919 = *_689918;
float _699025;
_699025 = _699022 + _699024;
float _699026;
_699026 = _689919;
float _699027;
_699027 = 4.000000e+00f * _699026;
float _689925;
_689925 = *_689924;
float _699028;
_699028 = _699025 + _699027;
float _699029;
_699029 = _689925;
float _699030;
_699030 = _699028 + _699029;
float _689934;
_689934 = *_689933;
float _699031;
_699031 = 6.000000e+00f * _699030;
float _699033;
_699033 = _689934;
float _699032;
_699032 = _699018 + _699031;
float _689941;
_689941 = *_689940;
float _699034;
_699034 = _689941;
float _699035;
_699035 = 4.000000e+00f * _699034;
float _689948;
_689948 = *_689947;
float _699036;
_699036 = _699033 + _699035;
float _699037;
_699037 = _689948;
float _699038;
_699038 = 6.000000e+00f * _699037;
float _689954;
_689954 = *_689953;
float _699039;
_699039 = _699036 + _699038;
float _699040;
_699040 = _689954;
float _699041;
_699041 = 4.000000e+00f * _699040;
float _689960;
_689960 = *_689959;
float _699042;
_699042 = _699039 + _699041;
float _699043;
_699043 = _689960;
float _699044;
_699044 = _699042 + _699043;
float _689969;
_689969 = *_689968;
float _699045;
_699045 = 4.000000e+00f * _699044;
float _699047;
_699047 = _689969;
float _699046;
_699046 = _699032 + _699045;
float _689976;
_689976 = *_689975;
float _699048;
_699048 = _689976;
float _699049;
_699049 = 4.000000e+00f * _699048;
float _689983;
_689983 = *_689982;
float _699050;
_699050 = _699047 + _699049;
float _699051;
_699051 = _689983;
float _699052;
_699052 = 6.000000e+00f * _699051;
float _689989;
_689989 = *_689988;
float _699053;
_699053 = _699050 + _699052;
float _699054;
_699054 = _689989;
float _699055;
_699055 = 4.000000e+00f * _699054;
float _689995;
_689995 = *_689994;
float _699056;
_699056 = _699053 + _699055;
float _699057;
_699057 = _689995;
float _699058;
_699058 = _699056 + _699057;
float _690005;
_690005 = *_690004;
float _699059;
_699059 = _699046 + _699058;
float _699062;
_699062 = _690005;
float _699060;
_699060 = 4.000000e+00f * _699059;
float _690012;
_690012 = *_690011;
float _699061;
_699061 = _698992 + _699060;
float _699063;
_699063 = _690012;
float _699064;
_699064 = 4.000000e+00f * _699063;
float _690019;
_690019 = *_690018;
float _699065;
_699065 = _699062 + _699064;
float _699066;
_699066 = _690019;
float _699067;
_699067 = 6.000000e+00f * _699066;
float _690025;
_690025 = *_690024;
float _699068;
_699068 = _699065 + _699067;
float _699069;
_699069 = _690025;
float _699070;
_699070 = 4.000000e+00f * _699069;
float _690031;
_690031 = *_690030;
float _699071;
_699071 = _699068 + _699070;
float _699072;
_699072 = _690031;
float _699073;
_699073 = _699071 + _699072;
float _690040;
_690040 = *_690039;
float _699074;
_699074 = _690040;
float _690047;
_690047 = *_690046;
float _699075;
_699075 = _690047;
float _699076;
_699076 = 4.000000e+00f * _699075;
float _690054;
_690054 = *_690053;
float _699077;
_699077 = _699074 + _699076;
float _699078;
_699078 = _690054;
float _699079;
_699079 = 6.000000e+00f * _699078;
float _690060;
_690060 = *_690059;
float _699080;
_699080 = _699077 + _699079;
float _699081;
_699081 = _690060;
float _699082;
_699082 = 4.000000e+00f * _699081;
float _690066;
_690066 = *_690065;
float _699083;
_699083 = _699080 + _699082;
float _699084;
_699084 = _690066;
float _699085;
_699085 = _699083 + _699084;
float _690075;
_690075 = *_690074;
float _699086;
_699086 = 4.000000e+00f * _699085;
float _699088;
_699088 = _690075;
float _699087;
_699087 = _699073 + _699086;
float _690082;
_690082 = *_690081;
float _699089;
_699089 = _690082;
float _699090;
_699090 = 4.000000e+00f * _699089;
float _690089;
_690089 = *_690088;
float _699091;
_699091 = _699088 + _699090;
float _699092;
_699092 = _690089;
float _699093;
_699093 = 6.000000e+00f * _699092;
float _690095;
_690095 = *_690094;
float _699094;
_699094 = _699091 + _699093;
float _699095;
_699095 = _690095;
float _699096;
_699096 = 4.000000e+00f * _699095;
float _690101;
_690101 = *_690100;
float _699097;
_699097 = _699094 + _699096;
float _699098;
_699098 = _690101;
float _699099;
_699099 = _699097 + _699098;
float _690110;
_690110 = *_690109;
float _699100;
_699100 = 6.000000e+00f * _699099;
float _699102;
_699102 = _690110;
float _699101;
_699101 = _699087 + _699100;
float _690117;
_690117 = *_690116;
float _699103;
_699103 = _690117;
float _699104;
_699104 = 4.000000e+00f * _699103;
float _690124;
_690124 = *_690123;
float _699105;
_699105 = _699102 + _699104;
float _699106;
_699106 = _690124;
float _699107;
_699107 = 6.000000e+00f * _699106;
float _690130;
_690130 = *_690129;
float _699108;
_699108 = _699105 + _699107;
float _699109;
_699109 = _690130;
float _699110;
_699110 = 4.000000e+00f * _699109;
float _690136;
_690136 = *_690135;
float _699111;
_699111 = _699108 + _699110;
float _699112;
_699112 = _690136;
float _699113;
_699113 = _699111 + _699112;
float _690145;
_690145 = *_690144;
float _699114;
_699114 = 4.000000e+00f * _699113;
float _699116;
_699116 = _690145;
float _699115;
_699115 = _699101 + _699114;
float _690152;
_690152 = *_690151;
float _699117;
_699117 = _690152;
float _699118;
_699118 = 4.000000e+00f * _699117;
float _690159;
_690159 = *_690158;
float _699119;
_699119 = _699116 + _699118;
float _699120;
_699120 = _690159;
float _699121;
_699121 = 6.000000e+00f * _699120;
float _690165;
_690165 = *_690164;
float _699122;
_699122 = _699119 + _699121;
float _699123;
_699123 = _690165;
float _699124;
_699124 = 4.000000e+00f * _699123;
float _690171;
_690171 = *_690170;
float _699125;
_699125 = _699122 + _699124;
float _699126;
_699126 = _690171;
float _699127;
_699127 = _699125 + _699126;
float _690181;
_690181 = *_690180;
float _699128;
_699128 = _699115 + _699127;
float _699131;
_699131 = _690181;
float _699129;
_699129 = 6.000000e+00f * _699128;
float _690188;
_690188 = *_690187;
float _699130;
_699130 = _699061 + _699129;
float _699132;
_699132 = _690188;
float _699133;
_699133 = 4.000000e+00f * _699132;
float _690195;
_690195 = *_690194;
float _699134;
_699134 = _699131 + _699133;
float _699135;
_699135 = _690195;
float _699136;
_699136 = 6.000000e+00f * _699135;
float _690201;
_690201 = *_690200;
float _699137;
_699137 = _699134 + _699136;
float _699138;
_699138 = _690201;
float _699139;
_699139 = 4.000000e+00f * _699138;
float _690207;
_690207 = *_690206;
float _699140;
_699140 = _699137 + _699139;
float _699141;
_699141 = _690207;
float _699142;
_699142 = _699140 + _699141;
float _690216;
_690216 = *_690215;
float _699143;
_699143 = _690216;
float _690223;
_690223 = *_690222;
float _699144;
_699144 = _690223;
float _699145;
_699145 = 4.000000e+00f * _699144;
float _690230;
_690230 = *_690229;
float _699146;
_699146 = _699143 + _699145;
float _699147;
_699147 = _690230;
float _699148;
_699148 = 6.000000e+00f * _699147;
float _690236;
_690236 = *_690235;
float _699149;
_699149 = _699146 + _699148;
float _699150;
_699150 = _690236;
float _699151;
_699151 = 4.000000e+00f * _699150;
float _690242;
_690242 = *_690241;
float _699152;
_699152 = _699149 + _699151;
float _699153;
_699153 = _690242;
float _699154;
_699154 = _699152 + _699153;
float _690251;
_690251 = *_690250;
float _699155;
_699155 = 4.000000e+00f * _699154;
float _699157;
_699157 = _690251;
float _699156;
_699156 = _699142 + _699155;
float _690258;
_690258 = *_690257;
float _699158;
_699158 = _690258;
float _699159;
_699159 = 4.000000e+00f * _699158;
float _690265;
_690265 = *_690264;
float _699160;
_699160 = _699157 + _699159;
float _699161;
_699161 = _690265;
float _699162;
_699162 = 6.000000e+00f * _699161;
float _690271;
_690271 = *_690270;
float _699163;
_699163 = _699160 + _699162;
float _699164;
_699164 = _690271;
float _699165;
_699165 = 4.000000e+00f * _699164;
float _690277;
_690277 = *_690276;
float _699166;
_699166 = _699163 + _699165;
float _699167;
_699167 = _690277;
float _699168;
_699168 = _699166 + _699167;
float _690286;
_690286 = *_690285;
float _699169;
_699169 = 6.000000e+00f * _699168;
float _699171;
_699171 = _690286;
float _699170;
_699170 = _699156 + _699169;
float _690293;
_690293 = *_690292;
float _699172;
_699172 = _690293;
float _699173;
_699173 = 4.000000e+00f * _699172;
float _690300;
_690300 = *_690299;
float _699174;
_699174 = _699171 + _699173;
float _699175;
_699175 = _690300;
float _699176;
_699176 = 6.000000e+00f * _699175;
float _690306;
_690306 = *_690305;
float _699177;
_699177 = _699174 + _699176;
float _699178;
_699178 = _690306;
float _699179;
_699179 = 4.000000e+00f * _699178;
float _690312;
_690312 = *_690311;
float _699180;
_699180 = _699177 + _699179;
float _699181;
_699181 = _690312;
float _699182;
_699182 = _699180 + _699181;
float _690321;
_690321 = *_690320;
float _699183;
_699183 = 4.000000e+00f * _699182;
float _699185;
_699185 = _690321;
float _699184;
_699184 = _699170 + _699183;
float _690328;
_690328 = *_690327;
float _699186;
_699186 = _690328;
float _699187;
_699187 = 4.000000e+00f * _699186;
float _690335;
_690335 = *_690334;
float _699188;
_699188 = _699185 + _699187;
float _699189;
_699189 = _690335;
float _699190;
_699190 = 6.000000e+00f * _699189;
float _690341;
_690341 = *_690340;
float _699191;
_699191 = _699188 + _699190;
float _699192;
_699192 = _690341;
float _699193;
_699193 = 4.000000e+00f * _699192;
float _690347;
_690347 = *_690346;
float _699194;
_699194 = _699191 + _699193;
float _699195;
_699195 = _690347;
float _699196;
_699196 = _699194 + _699195;
float _690357;
_690357 = *_690356;
float _699197;
_699197 = _699184 + _699196;
float _699200;
_699200 = _690357;
float _699198;
_699198 = 4.000000e+00f * _699197;
float _690364;
_690364 = *_690363;
float _699199;
_699199 = _699130 + _699198;
float _699201;
_699201 = _690364;
float _699202;
_699202 = 4.000000e+00f * _699201;
float _690371;
_690371 = *_690370;
float _699203;
_699203 = _699200 + _699202;
float _699204;
_699204 = _690371;
float _699205;
_699205 = 6.000000e+00f * _699204;
float _690377;
_690377 = *_690376;
float _699206;
_699206 = _699203 + _699205;
float _699207;
_699207 = _690377;
float _699208;
_699208 = 4.000000e+00f * _699207;
float _690383;
_690383 = *_690382;
float _699209;
_699209 = _699206 + _699208;
float _699210;
_699210 = _690383;
float _699211;
_699211 = _699209 + _699210;
float _690392;
_690392 = *_690391;
float _699212;
_699212 = _690392;
float _690399;
_690399 = *_690398;
float _699213;
_699213 = _690399;
float _699214;
_699214 = 4.000000e+00f * _699213;
float _690406;
_690406 = *_690405;
float _699215;
_699215 = _699212 + _699214;
float _699216;
_699216 = _690406;
float _699217;
_699217 = 6.000000e+00f * _699216;
float _690412;
_690412 = *_690411;
float _699218;
_699218 = _699215 + _699217;
float _699219;
_699219 = _690412;
float _699220;
_699220 = 4.000000e+00f * _699219;
float _690418;
_690418 = *_690417;
float _699221;
_699221 = _699218 + _699220;
float _699222;
_699222 = _690418;
float _699223;
_699223 = _699221 + _699222;
float _690427;
_690427 = *_690426;
float _699224;
_699224 = 4.000000e+00f * _699223;
float _699226;
_699226 = _690427;
float _699225;
_699225 = _699211 + _699224;
float _690434;
_690434 = *_690433;
float _699227;
_699227 = _690434;
float _699228;
_699228 = 4.000000e+00f * _699227;
float _690441;
_690441 = *_690440;
float _699229;
_699229 = _699226 + _699228;
float _699230;
_699230 = _690441;
float _699231;
_699231 = 6.000000e+00f * _699230;
float _690447;
_690447 = *_690446;
float _699232;
_699232 = _699229 + _699231;
float _699233;
_699233 = _690447;
float _699234;
_699234 = 4.000000e+00f * _699233;
float _690453;
_690453 = *_690452;
float _699235;
_699235 = _699232 + _699234;
float _699236;
_699236 = _690453;
float _699237;
_699237 = _699235 + _699236;
float _690462;
_690462 = *_690461;
float _699238;
_699238 = 6.000000e+00f * _699237;
float _699240;
_699240 = _690462;
float _699239;
_699239 = _699225 + _699238;
float _690469;
_690469 = *_690468;
float _699241;
_699241 = _690469;
float _699242;
_699242 = 4.000000e+00f * _699241;
float _690476;
_690476 = *_690475;
float _699243;
_699243 = _699240 + _699242;
float _699244;
_699244 = _690476;
float _699245;
_699245 = 6.000000e+00f * _699244;
float _690482;
_690482 = *_690481;
float _699246;
_699246 = _699243 + _699245;
float _699247;
_699247 = _690482;
float _699248;
_699248 = 4.000000e+00f * _699247;
float _690488;
_690488 = *_690487;
float _699249;
_699249 = _699246 + _699248;
float _699250;
_699250 = _690488;
float _699251;
_699251 = _699249 + _699250;
float _690497;
_690497 = *_690496;
float _699252;
_699252 = 4.000000e+00f * _699251;
float _699254;
_699254 = _690497;
float _699253;
_699253 = _699239 + _699252;
float _690504;
_690504 = *_690503;
float _699255;
_699255 = _690504;
float _699256;
_699256 = 4.000000e+00f * _699255;
float _690511;
_690511 = *_690510;
float _699257;
_699257 = _699254 + _699256;
float _699258;
_699258 = _690511;
float _699259;
_699259 = 6.000000e+00f * _699258;
float _690517;
_690517 = *_690516;
float _699260;
_699260 = _699257 + _699259;
float _699261;
_699261 = _690517;
float _699262;
_699262 = 4.000000e+00f * _699261;
float _690523;
_690523 = *_690522;
float _699263;
_699263 = _699260 + _699262;
float _699264;
_699264 = _690523;
float _699265;
_699265 = _699263 + _699264;
float _690533;
_690533 = *_690532;
float _699266;
_699266 = _699253 + _699265;
float _699271;
_699271 = _690533;
float _699267;
_699267 = _699199 + _699266;
float _690540;
_690540 = *_690539;
float _699268;
_699268 = xf_695819 * _699267;
float _699272;
_699272 = _690540;
float _699269;
_699269 = _698925 + _699268;
float _699273;
_699273 = 4.000000e+00f * _699272;
float _690547;
_690547 = *_690546;
float _699270;
_699270 = _695816 * _699269;
float _699274;
_699274 = _699271 + _699273;
float _699275;
_699275 = _690547;
float _699276;
_699276 = 6.000000e+00f * _699275;
float _690553;
_690553 = *_690552;
float _699277;
_699277 = _699274 + _699276;
float _699278;
_699278 = _690553;
float _699279;
_699279 = 4.000000e+00f * _699278;
float _690559;
_690559 = *_690558;
float _699280;
_699280 = _699277 + _699279;
float _699281;
_699281 = _690559;
float _699282;
_699282 = _699280 + _699281;
float _690568;
_690568 = *_690567;
float _699283;
_699283 = _690568;
float _690575;
_690575 = *_690574;
float _699284;
_699284 = _690575;
float _699285;
_699285 = 4.000000e+00f * _699284;
float _690582;
_690582 = *_690581;
float _699286;
_699286 = _699283 + _699285;
float _699287;
_699287 = _690582;
float _699288;
_699288 = 6.000000e+00f * _699287;
float _690588;
_690588 = *_690587;
float _699289;
_699289 = _699286 + _699288;
float _699290;
_699290 = _690588;
float _699291;
_699291 = 4.000000e+00f * _699290;
float _690594;
_690594 = *_690593;
float _699292;
_699292 = _699289 + _699291;
float _699293;
_699293 = _690594;
float _699294;
_699294 = _699292 + _699293;
float _690603;
_690603 = *_690602;
float _699295;
_699295 = 4.000000e+00f * _699294;
float _699297;
_699297 = _690603;
float _699296;
_699296 = _699282 + _699295;
float _690610;
_690610 = *_690609;
float _699298;
_699298 = _690610;
float _699299;
_699299 = 4.000000e+00f * _699298;
float _690617;
_690617 = *_690616;
float _699300;
_699300 = _699297 + _699299;
float _699301;
_699301 = _690617;
float _699302;
_699302 = 6.000000e+00f * _699301;
float _690623;
_690623 = *_690622;
float _699303;
_699303 = _699300 + _699302;
float _699304;
_699304 = _690623;
float _699305;
_699305 = 4.000000e+00f * _699304;
float _690629;
_690629 = *_690628;
float _699306;
_699306 = _699303 + _699305;
float _699307;
_699307 = _690629;
float _699308;
_699308 = _699306 + _699307;
float _690638;
_690638 = *_690637;
float _699309;
_699309 = 6.000000e+00f * _699308;
float _699311;
_699311 = _690638;
float _699310;
_699310 = _699296 + _699309;
float _690645;
_690645 = *_690644;
float _699312;
_699312 = _690645;
float _699313;
_699313 = 4.000000e+00f * _699312;
float _690652;
_690652 = *_690651;
float _699314;
_699314 = _699311 + _699313;
float _699315;
_699315 = _690652;
float _699316;
_699316 = 6.000000e+00f * _699315;
float _690658;
_690658 = *_690657;
float _699317;
_699317 = _699314 + _699316;
float _699318;
_699318 = _690658;
float _699319;
_699319 = 4.000000e+00f * _699318;
float _690664;
_690664 = *_690663;
float _699320;
_699320 = _699317 + _699319;
float _699321;
_699321 = _690664;
float _699322;
_699322 = _699320 + _699321;
float _690673;
_690673 = *_690672;
float _699323;
_699323 = 4.000000e+00f * _699322;
float _699325;
_699325 = _690673;
float _699324;
_699324 = _699310 + _699323;
float _690680;
_690680 = *_690679;
float _699326;
_699326 = _690680;
float _699327;
_699327 = 4.000000e+00f * _699326;
float _690687;
_690687 = *_690686;
float _699328;
_699328 = _699325 + _699327;
float _699329;
_699329 = _690687;
float _699330;
_699330 = 6.000000e+00f * _699329;
float _690693;
_690693 = *_690692;
float _699331;
_699331 = _699328 + _699330;
float _699332;
_699332 = _690693;
float _699333;
_699333 = 4.000000e+00f * _699332;
float _690699;
_690699 = *_690698;
float _699334;
_699334 = _699331 + _699333;
float _699335;
_699335 = _690699;
float _699336;
_699336 = _699334 + _699335;
float _690709;
_690709 = *_690708;
float _699337;
_699337 = _699324 + _699336;
float _699338;
_699338 = _690709;
float _690716;
_690716 = *_690715;
float _699339;
_699339 = _690716;
float _699340;
_699340 = 4.000000e+00f * _699339;
float _690723;
_690723 = *_690722;
float _699341;
_699341 = _699338 + _699340;
float _699342;
_699342 = _690723;
float _699343;
_699343 = 6.000000e+00f * _699342;
float _690729;
_690729 = *_690728;
float _699344;
_699344 = _699341 + _699343;
float _699345;
_699345 = _690729;
float _699346;
_699346 = 4.000000e+00f * _699345;
float _690735;
_690735 = *_690734;
float _699347;
_699347 = _699344 + _699346;
float _699348;
_699348 = _690735;
float _699349;
_699349 = _699347 + _699348;
float _690744;
_690744 = *_690743;
float _699350;
_699350 = _690744;
float _690751;
_690751 = *_690750;
float _699351;
_699351 = _690751;
float _699352;
_699352 = 4.000000e+00f * _699351;
float _690758;
_690758 = *_690757;
float _699353;
_699353 = _699350 + _699352;
float _699354;
_699354 = _690758;
float _699355;
_699355 = 6.000000e+00f * _699354;
float _690764;
_690764 = *_690763;
float _699356;
_699356 = _699353 + _699355;
float _699357;
_699357 = _690764;
float _699358;
_699358 = 4.000000e+00f * _699357;
float _690770;
_690770 = *_690769;
float _699359;
_699359 = _699356 + _699358;
float _699360;
_699360 = _690770;
float _699361;
_699361 = _699359 + _699360;
float _690779;
_690779 = *_690778;
float _699362;
_699362 = 4.000000e+00f * _699361;
float _699364;
_699364 = _690779;
float _699363;
_699363 = _699349 + _699362;
float _690786;
_690786 = *_690785;
float _699365;
_699365 = _690786;
float _699366;
_699366 = 4.000000e+00f * _699365;
float _690793;
_690793 = *_690792;
float _699367;
_699367 = _699364 + _699366;
float _699368;
_699368 = _690793;
float _699369;
_699369 = 6.000000e+00f * _699368;
float _690799;
_690799 = *_690798;
float _699370;
_699370 = _699367 + _699369;
float _699371;
_699371 = _690799;
float _699372;
_699372 = 4.000000e+00f * _699371;
float _690805;
_690805 = *_690804;
float _699373;
_699373 = _699370 + _699372;
float _699374;
_699374 = _690805;
float _699375;
_699375 = _699373 + _699374;
float _690814;
_690814 = *_690813;
float _699376;
_699376 = 6.000000e+00f * _699375;
float _699378;
_699378 = _690814;
float _699377;
_699377 = _699363 + _699376;
float _690821;
_690821 = *_690820;
float _699379;
_699379 = _690821;
float _699380;
_699380 = 4.000000e+00f * _699379;
float _690828;
_690828 = *_690827;
float _699381;
_699381 = _699378 + _699380;
float _699382;
_699382 = _690828;
float _699383;
_699383 = 6.000000e+00f * _699382;
float _690834;
_690834 = *_690833;
float _699384;
_699384 = _699381 + _699383;
float _699385;
_699385 = _690834;
float _699386;
_699386 = 4.000000e+00f * _699385;
float _690840;
_690840 = *_690839;
float _699387;
_699387 = _699384 + _699386;
float _699388;
_699388 = _690840;
float _699389;
_699389 = _699387 + _699388;
float _690849;
_690849 = *_690848;
float _699390;
_699390 = 4.000000e+00f * _699389;
float _699392;
_699392 = _690849;
float _699391;
_699391 = _699377 + _699390;
float _690856;
_690856 = *_690855;
float _699393;
_699393 = _690856;
float _699394;
_699394 = 4.000000e+00f * _699393;
float _690863;
_690863 = *_690862;
float _699395;
_699395 = _699392 + _699394;
float _699396;
_699396 = _690863;
float _699397;
_699397 = 6.000000e+00f * _699396;
float _690869;
_690869 = *_690868;
float _699398;
_699398 = _699395 + _699397;
float _699399;
_699399 = _690869;
float _699400;
_699400 = 4.000000e+00f * _699399;
float _690875;
_690875 = *_690874;
float _699401;
_699401 = _699398 + _699400;
float _699402;
_699402 = _690875;
float _699403;
_699403 = _699401 + _699402;
float _690885;
_690885 = *_690884;
float _699404;
_699404 = _699391 + _699403;
float _699407;
_699407 = _690885;
float _699405;
_699405 = 4.000000e+00f * _699404;
float _690892;
_690892 = *_690891;
float _699406;
_699406 = _699337 + _699405;
float _699408;
_699408 = _690892;
float _699409;
_699409 = 4.000000e+00f * _699408;
float _690899;
_690899 = *_690898;
float _699410;
_699410 = _699407 + _699409;
float _699411;
_699411 = _690899;
float _699412;
_699412 = 6.000000e+00f * _699411;
float _690905;
_690905 = *_690904;
float _699413;
_699413 = _699410 + _699412;
float _699414;
_699414 = _690905;
float _699415;
_699415 = 4.000000e+00f * _699414;
float _690911;
_690911 = *_690910;
float _699416;
_699416 = _699413 + _699415;
float _699417;
_699417 = _690911;
float _699418;
_699418 = _699416 + _699417;
float _690920;
_690920 = *_690919;
float _699419;
_699419 = _690920;
float _690927;
_690927 = *_690926;
float _699420;
_699420 = _690927;
float _699421;
_699421 = 4.000000e+00f * _699420;
float _690934;
_690934 = *_690933;
float _699422;
_699422 = _699419 + _699421;
float _699423;
_699423 = _690934;
float _699424;
_699424 = 6.000000e+00f * _699423;
float _690940;
_690940 = *_690939;
float _699425;
_699425 = _699422 + _699424;
float _699426;
_699426 = _690940;
float _699427;
_699427 = 4.000000e+00f * _699426;
float _690946;
_690946 = *_690945;
float _699428;
_699428 = _699425 + _699427;
float _699429;
_699429 = _690946;
float _699430;
_699430 = _699428 + _699429;
float _690955;
_690955 = *_690954;
float _699431;
_699431 = 4.000000e+00f * _699430;
float _699433;
_699433 = _690955;
float _699432;
_699432 = _699418 + _699431;
float _690962;
_690962 = *_690961;
float _699434;
_699434 = _690962;
float _699435;
_699435 = 4.000000e+00f * _699434;
float _690969;
_690969 = *_690968;
float _699436;
_699436 = _699433 + _699435;
float _699437;
_699437 = _690969;
float _699438;
_699438 = 6.000000e+00f * _699437;
float _690975;
_690975 = *_690974;
float _699439;
_699439 = _699436 + _699438;
float _699440;
_699440 = _690975;
float _699441;
_699441 = 4.000000e+00f * _699440;
float _690981;
_690981 = *_690980;
float _699442;
_699442 = _699439 + _699441;
float _699443;
_699443 = _690981;
float _699444;
_699444 = _699442 + _699443;
float _690990;
_690990 = *_690989;
float _699445;
_699445 = 6.000000e+00f * _699444;
float _699447;
_699447 = _690990;
float _699446;
_699446 = _699432 + _699445;
float _690997;
_690997 = *_690996;
float _699448;
_699448 = _690997;
float _699449;
_699449 = 4.000000e+00f * _699448;
float _691004;
_691004 = *_691003;
float _699450;
_699450 = _699447 + _699449;
float _699451;
_699451 = _691004;
float _699452;
_699452 = 6.000000e+00f * _699451;
float _691010;
_691010 = *_691009;
float _699453;
_699453 = _699450 + _699452;
float _699454;
_699454 = _691010;
float _699455;
_699455 = 4.000000e+00f * _699454;
float _691016;
_691016 = *_691015;
float _699456;
_699456 = _699453 + _699455;
float _699457;
_699457 = _691016;
float _699458;
_699458 = _699456 + _699457;
float _691025;
_691025 = *_691024;
float _699459;
_699459 = 4.000000e+00f * _699458;
float _699461;
_699461 = _691025;
float _699460;
_699460 = _699446 + _699459;
float _691032;
_691032 = *_691031;
float _699462;
_699462 = _691032;
float _699463;
_699463 = 4.000000e+00f * _699462;
float _691039;
_691039 = *_691038;
float _699464;
_699464 = _699461 + _699463;
float _699465;
_699465 = _691039;
float _699466;
_699466 = 6.000000e+00f * _699465;
float _691045;
_691045 = *_691044;
float _699467;
_699467 = _699464 + _699466;
float _699468;
_699468 = _691045;
float _699469;
_699469 = 4.000000e+00f * _699468;
float _691051;
_691051 = *_691050;
float _699470;
_699470 = _699467 + _699469;
float _699471;
_699471 = _691051;
float _699472;
_699472 = _699470 + _699471;
float _691061;
_691061 = *_691060;
float _699473;
_699473 = _699460 + _699472;
float _699476;
_699476 = _691061;
float _699474;
_699474 = 6.000000e+00f * _699473;
float _691068;
_691068 = *_691067;
float _699475;
_699475 = _699406 + _699474;
float _699477;
_699477 = _691068;
float _699478;
_699478 = 4.000000e+00f * _699477;
float _691075;
_691075 = *_691074;
float _699479;
_699479 = _699476 + _699478;
float _699480;
_699480 = _691075;
float _699481;
_699481 = 6.000000e+00f * _699480;
float _691081;
_691081 = *_691080;
float _699482;
_699482 = _699479 + _699481;
float _699483;
_699483 = _691081;
float _699484;
_699484 = 4.000000e+00f * _699483;
float _691087;
_691087 = *_691086;
float _699485;
_699485 = _699482 + _699484;
float _699486;
_699486 = _691087;
float _699487;
_699487 = _699485 + _699486;
float _691096;
_691096 = *_691095;
float _699488;
_699488 = _691096;
float _691103;
_691103 = *_691102;
float _699489;
_699489 = _691103;
float _699490;
_699490 = 4.000000e+00f * _699489;
float _691110;
_691110 = *_691109;
float _699491;
_699491 = _699488 + _699490;
float _699492;
_699492 = _691110;
float _699493;
_699493 = 6.000000e+00f * _699492;
float _691116;
_691116 = *_691115;
float _699494;
_699494 = _699491 + _699493;
float _699495;
_699495 = _691116;
float _699496;
_699496 = 4.000000e+00f * _699495;
float _691122;
_691122 = *_691121;
float _699497;
_699497 = _699494 + _699496;
float _699498;
_699498 = _691122;
float _699499;
_699499 = _699497 + _699498;
float _691131;
_691131 = *_691130;
float _699500;
_699500 = 4.000000e+00f * _699499;
float _699502;
_699502 = _691131;
float _699501;
_699501 = _699487 + _699500;
float _691138;
_691138 = *_691137;
float _699503;
_699503 = _691138;
float _699504;
_699504 = 4.000000e+00f * _699503;
float _691145;
_691145 = *_691144;
float _699505;
_699505 = _699502 + _699504;
float _699506;
_699506 = _691145;
float _699507;
_699507 = 6.000000e+00f * _699506;
float _691151;
_691151 = *_691150;
float _699508;
_699508 = _699505 + _699507;
float _699509;
_699509 = _691151;
float _699510;
_699510 = 4.000000e+00f * _699509;
float _691157;
_691157 = *_691156;
float _699511;
_699511 = _699508 + _699510;
float _699512;
_699512 = _691157;
float _699513;
_699513 = _699511 + _699512;
float _691166;
_691166 = *_691165;
float _699514;
_699514 = 6.000000e+00f * _699513;
float _699516;
_699516 = _691166;
float _699515;
_699515 = _699501 + _699514;
float _691173;
_691173 = *_691172;
float _699517;
_699517 = _691173;
float _699518;
_699518 = 4.000000e+00f * _699517;
float _691180;
_691180 = *_691179;
float _699519;
_699519 = _699516 + _699518;
float _699520;
_699520 = _691180;
float _699521;
_699521 = 6.000000e+00f * _699520;
float _691186;
_691186 = *_691185;
float _699522;
_699522 = _699519 + _699521;
float _699523;
_699523 = _691186;
float _699524;
_699524 = 4.000000e+00f * _699523;
float _691192;
_691192 = *_691191;
float _699525;
_699525 = _699522 + _699524;
float _699526;
_699526 = _691192;
float _699527;
_699527 = _699525 + _699526;
float _691201;
_691201 = *_691200;
float _699528;
_699528 = 4.000000e+00f * _699527;
float _699530;
_699530 = _691201;
float _699529;
_699529 = _699515 + _699528;
float _691208;
_691208 = *_691207;
float _699531;
_699531 = _691208;
float _699532;
_699532 = 4.000000e+00f * _699531;
float _691215;
_691215 = *_691214;
float _699533;
_699533 = _699530 + _699532;
float _699534;
_699534 = _691215;
float _699535;
_699535 = 6.000000e+00f * _699534;
float _691221;
_691221 = *_691220;
float _699536;
_699536 = _699533 + _699535;
float _699537;
_699537 = _691221;
float _699538;
_699538 = 4.000000e+00f * _699537;
float _691227;
_691227 = *_691226;
float _699539;
_699539 = _699536 + _699538;
float _699540;
_699540 = _691227;
float _699541;
_699541 = _699539 + _699540;
float _691237;
_691237 = *_691236;
float _699542;
_699542 = _699529 + _699541;
float _699545;
_699545 = _691237;
float _699543;
_699543 = 4.000000e+00f * _699542;
float _691244;
_691244 = *_691243;
float _699544;
_699544 = _699475 + _699543;
float _699546;
_699546 = _691244;
float _699547;
_699547 = 4.000000e+00f * _699546;
float _691251;
_691251 = *_691250;
float _699548;
_699548 = _699545 + _699547;
float _699549;
_699549 = _691251;
float _699550;
_699550 = 6.000000e+00f * _699549;
float _691257;
_691257 = *_691256;
float _699551;
_699551 = _699548 + _699550;
float _699552;
_699552 = _691257;
float _699553;
_699553 = 4.000000e+00f * _699552;
float _691263;
_691263 = *_691262;
float _699554;
_699554 = _699551 + _699553;
float _699555;
_699555 = _691263;
float _699556;
_699556 = _699554 + _699555;
float _691272;
_691272 = *_691271;
float _699557;
_699557 = _691272;
float _691279;
_691279 = *_691278;
float _699558;
_699558 = _691279;
float _699559;
_699559 = 4.000000e+00f * _699558;
float _691286;
_691286 = *_691285;
float _699560;
_699560 = _699557 + _699559;
float _699561;
_699561 = _691286;
float _699562;
_699562 = 6.000000e+00f * _699561;
float _691292;
_691292 = *_691291;
float _699563;
_699563 = _699560 + _699562;
float _699564;
_699564 = _691292;
float _699565;
_699565 = 4.000000e+00f * _699564;
float _691298;
_691298 = *_691297;
float _699566;
_699566 = _699563 + _699565;
float _699567;
_699567 = _691298;
float _699568;
_699568 = _699566 + _699567;
float _691307;
_691307 = *_691306;
float _699569;
_699569 = 4.000000e+00f * _699568;
float _699571;
_699571 = _691307;
float _699570;
_699570 = _699556 + _699569;
float _691314;
_691314 = *_691313;
float _699572;
_699572 = _691314;
float _699573;
_699573 = 4.000000e+00f * _699572;
float _691321;
_691321 = *_691320;
float _699574;
_699574 = _699571 + _699573;
float _699575;
_699575 = _691321;
float _699576;
_699576 = 6.000000e+00f * _699575;
float _691327;
_691327 = *_691326;
float _699577;
_699577 = _699574 + _699576;
float _699578;
_699578 = _691327;
float _699579;
_699579 = 4.000000e+00f * _699578;
float _691333;
_691333 = *_691332;
float _699580;
_699580 = _699577 + _699579;
float _699581;
_699581 = _691333;
float _699582;
_699582 = _699580 + _699581;
float _691342;
_691342 = *_691341;
float _699583;
_699583 = 6.000000e+00f * _699582;
float _699585;
_699585 = _691342;
float _699584;
_699584 = _699570 + _699583;
float _691349;
_691349 = *_691348;
float _699586;
_699586 = _691349;
float _699587;
_699587 = 4.000000e+00f * _699586;
float _691356;
_691356 = *_691355;
float _699588;
_699588 = _699585 + _699587;
float _699589;
_699589 = _691356;
float _699590;
_699590 = 6.000000e+00f * _699589;
float _691362;
_691362 = *_691361;
float _699591;
_699591 = _699588 + _699590;
float _699592;
_699592 = _691362;
float _699593;
_699593 = 4.000000e+00f * _699592;
float _691368;
_691368 = *_691367;
float _699594;
_699594 = _699591 + _699593;
float _699595;
_699595 = _691368;
float _699596;
_699596 = _699594 + _699595;
float _691377;
_691377 = *_691376;
float _699597;
_699597 = 4.000000e+00f * _699596;
float _699599;
_699599 = _691377;
float _699598;
_699598 = _699584 + _699597;
float _691384;
_691384 = *_691383;
float _699600;
_699600 = _691384;
float _699601;
_699601 = 4.000000e+00f * _699600;
float _691391;
_691391 = *_691390;
float _699602;
_699602 = _699599 + _699601;
float _699603;
_699603 = _691391;
float _699604;
_699604 = 6.000000e+00f * _699603;
float _691397;
_691397 = *_691396;
float _699605;
_699605 = _699602 + _699604;
float _699606;
_699606 = _691397;
float _699607;
_699607 = 4.000000e+00f * _699606;
float _691403;
_691403 = *_691402;
float _699608;
_699608 = _699605 + _699607;
float _699609;
_699609 = _691403;
float _699610;
_699610 = _699608 + _699609;
float _691413;
_691413 = *_691412;
float _699611;
_699611 = _699598 + _699610;
float _699614;
_699614 = _691413;
float _699612;
_699612 = _699544 + _699611;
float _691420;
_691420 = *_691419;
float _699613;
_699613 = _695820 * _699612;
float _699615;
_699615 = _691420;
float _699616;
_699616 = 4.000000e+00f * _699615;
float _691427;
_691427 = *_691426;
float _699617;
_699617 = _699614 + _699616;
float _699618;
_699618 = _691427;
float _699619;
_699619 = 6.000000e+00f * _699618;
float _691433;
_691433 = *_691432;
float _699620;
_699620 = _699617 + _699619;
float _699621;
_699621 = _691433;
float _699622;
_699622 = 4.000000e+00f * _699621;
float _691439;
_691439 = *_691438;
float _699623;
_699623 = _699620 + _699622;
float _699624;
_699624 = _691439;
float _699625;
_699625 = _699623 + _699624;
float _691448;
_691448 = *_691447;
float _699626;
_699626 = _691448;
float _691455;
_691455 = *_691454;
float _699627;
_699627 = _691455;
float _699628;
_699628 = 4.000000e+00f * _699627;
float _691462;
_691462 = *_691461;
float _699629;
_699629 = _699626 + _699628;
float _699630;
_699630 = _691462;
float _699631;
_699631 = 6.000000e+00f * _699630;
float _691468;
_691468 = *_691467;
float _699632;
_699632 = _699629 + _699631;
float _699633;
_699633 = _691468;
float _699634;
_699634 = 4.000000e+00f * _699633;
float _691474;
_691474 = *_691473;
float _699635;
_699635 = _699632 + _699634;
float _699636;
_699636 = _691474;
float _699637;
_699637 = _699635 + _699636;
float _691483;
_691483 = *_691482;
float _699638;
_699638 = 4.000000e+00f * _699637;
float _699640;
_699640 = _691483;
float _699639;
_699639 = _699625 + _699638;
float _691490;
_691490 = *_691489;
float _699641;
_699641 = _691490;
float _699642;
_699642 = 4.000000e+00f * _699641;
float _691497;
_691497 = *_691496;
float _699643;
_699643 = _699640 + _699642;
float _699644;
_699644 = _691497;
float _699645;
_699645 = 6.000000e+00f * _699644;
float _691503;
_691503 = *_691502;
float _699646;
_699646 = _699643 + _699645;
float _699647;
_699647 = _691503;
float _699648;
_699648 = 4.000000e+00f * _699647;
float _691509;
_691509 = *_691508;
float _699649;
_699649 = _699646 + _699648;
float _699650;
_699650 = _691509;
float _699651;
_699651 = _699649 + _699650;
float _691518;
_691518 = *_691517;
float _699652;
_699652 = 6.000000e+00f * _699651;
float _699654;
_699654 = _691518;
float _699653;
_699653 = _699639 + _699652;
float _691525;
_691525 = *_691524;
float _699655;
_699655 = _691525;
float _699656;
_699656 = 4.000000e+00f * _699655;
float _691532;
_691532 = *_691531;
float _699657;
_699657 = _699654 + _699656;
float _699658;
_699658 = _691532;
float _699659;
_699659 = 6.000000e+00f * _699658;
float _691538;
_691538 = *_691537;
float _699660;
_699660 = _699657 + _699659;
float _699661;
_699661 = _691538;
float _699662;
_699662 = 4.000000e+00f * _699661;
float _691544;
_691544 = *_691543;
float _699663;
_699663 = _699660 + _699662;
float _699664;
_699664 = _691544;
float _699665;
_699665 = _699663 + _699664;
float _691553;
_691553 = *_691552;
float _699666;
_699666 = 4.000000e+00f * _699665;
float _699668;
_699668 = _691553;
float _699667;
_699667 = _699653 + _699666;
float _691560;
_691560 = *_691559;
float _699669;
_699669 = _691560;
float _699670;
_699670 = 4.000000e+00f * _699669;
float _691567;
_691567 = *_691566;
float _699671;
_699671 = _699668 + _699670;
float _699672;
_699672 = _691567;
float _699673;
_699673 = 6.000000e+00f * _699672;
float _691573;
_691573 = *_691572;
float _699674;
_699674 = _699671 + _699673;
float _699675;
_699675 = _691573;
float _699676;
_699676 = 4.000000e+00f * _699675;
float _691579;
_691579 = *_691578;
float _699677;
_699677 = _699674 + _699676;
float _699678;
_699678 = _691579;
float _699679;
_699679 = _699677 + _699678;
float _691589;
_691589 = *_691588;
float _699680;
_699680 = _699667 + _699679;
float _699681;
_699681 = _691589;
float _691596;
_691596 = *_691595;
float _699682;
_699682 = _691596;
float _699683;
_699683 = 4.000000e+00f * _699682;
float _691603;
_691603 = *_691602;
float _699684;
_699684 = _699681 + _699683;
float _699685;
_699685 = _691603;
float _699686;
_699686 = 6.000000e+00f * _699685;
float _691609;
_691609 = *_691608;
float _699687;
_699687 = _699684 + _699686;
float _699688;
_699688 = _691609;
float _699689;
_699689 = 4.000000e+00f * _699688;
float _691615;
_691615 = *_691614;
float _699690;
_699690 = _699687 + _699689;
float _699691;
_699691 = _691615;
float _699692;
_699692 = _699690 + _699691;
float _691624;
_691624 = *_691623;
float _699693;
_699693 = _691624;
float _691631;
_691631 = *_691630;
float _699694;
_699694 = _691631;
float _699695;
_699695 = 4.000000e+00f * _699694;
float _691638;
_691638 = *_691637;
float _699696;
_699696 = _699693 + _699695;
float _699697;
_699697 = _691638;
float _699698;
_699698 = 6.000000e+00f * _699697;
float _691644;
_691644 = *_691643;
float _699699;
_699699 = _699696 + _699698;
float _699700;
_699700 = _691644;
float _699701;
_699701 = 4.000000e+00f * _699700;
float _691650;
_691650 = *_691649;
float _699702;
_699702 = _699699 + _699701;
float _699703;
_699703 = _691650;
float _699704;
_699704 = _699702 + _699703;
float _691659;
_691659 = *_691658;
float _699705;
_699705 = 4.000000e+00f * _699704;
float _699707;
_699707 = _691659;
float _699706;
_699706 = _699692 + _699705;
float _691666;
_691666 = *_691665;
float _699708;
_699708 = _691666;
float _699709;
_699709 = 4.000000e+00f * _699708;
float _691673;
_691673 = *_691672;
float _699710;
_699710 = _699707 + _699709;
float _699711;
_699711 = _691673;
float _699712;
_699712 = 6.000000e+00f * _699711;
float _691679;
_691679 = *_691678;
float _699713;
_699713 = _699710 + _699712;
float _699714;
_699714 = _691679;
float _699715;
_699715 = 4.000000e+00f * _699714;
float _691685;
_691685 = *_691684;
float _699716;
_699716 = _699713 + _699715;
float _699717;
_699717 = _691685;
float _699718;
_699718 = _699716 + _699717;
float _691694;
_691694 = *_691693;
float _699719;
_699719 = 6.000000e+00f * _699718;
float _699721;
_699721 = _691694;
float _699720;
_699720 = _699706 + _699719;
float _691701;
_691701 = *_691700;
float _699722;
_699722 = _691701;
float _699723;
_699723 = 4.000000e+00f * _699722;
float _691708;
_691708 = *_691707;
float _699724;
_699724 = _699721 + _699723;
float _699725;
_699725 = _691708;
float _699726;
_699726 = 6.000000e+00f * _699725;
float _691714;
_691714 = *_691713;
float _699727;
_699727 = _699724 + _699726;
float _699728;
_699728 = _691714;
float _699729;
_699729 = 4.000000e+00f * _699728;
float _691720;
_691720 = *_691719;
float _699730;
_699730 = _699727 + _699729;
float _699731;
_699731 = _691720;
float _699732;
_699732 = _699730 + _699731;
float _691729;
_691729 = *_691728;
float _699733;
_699733 = 4.000000e+00f * _699732;
float _699735;
_699735 = _691729;
float _699734;
_699734 = _699720 + _699733;
float _691736;
_691736 = *_691735;
float _699736;
_699736 = _691736;
float _699737;
_699737 = 4.000000e+00f * _699736;
float _691743;
_691743 = *_691742;
float _699738;
_699738 = _699735 + _699737;
float _699739;
_699739 = _691743;
float _699740;
_699740 = 6.000000e+00f * _699739;
float _691749;
_691749 = *_691748;
float _699741;
_699741 = _699738 + _699740;
float _699742;
_699742 = _691749;
float _699743;
_699743 = 4.000000e+00f * _699742;
float _691755;
_691755 = *_691754;
float _699744;
_699744 = _699741 + _699743;
float _699745;
_699745 = _691755;
float _699746;
_699746 = _699744 + _699745;
float _691765;
_691765 = *_691764;
float _699747;
_699747 = _699734 + _699746;
float _699750;
_699750 = _691765;
float _699748;
_699748 = 4.000000e+00f * _699747;
float _691772;
_691772 = *_691771;
float _699749;
_699749 = _699680 + _699748;
float _699751;
_699751 = _691772;
float _699752;
_699752 = 4.000000e+00f * _699751;
float _691779;
_691779 = *_691778;
float _699753;
_699753 = _699750 + _699752;
float _699754;
_699754 = _691779;
float _699755;
_699755 = 6.000000e+00f * _699754;
float _691785;
_691785 = *_691784;
float _699756;
_699756 = _699753 + _699755;
float _699757;
_699757 = _691785;
float _699758;
_699758 = 4.000000e+00f * _699757;
float _691791;
_691791 = *_691790;
float _699759;
_699759 = _699756 + _699758;
float _699760;
_699760 = _691791;
float _699761;
_699761 = _699759 + _699760;
float _691800;
_691800 = *_691799;
float _699762;
_699762 = _691800;
float _691807;
_691807 = *_691806;
float _699763;
_699763 = _691807;
float _699764;
_699764 = 4.000000e+00f * _699763;
float _691814;
_691814 = *_691813;
float _699765;
_699765 = _699762 + _699764;
float _699766;
_699766 = _691814;
float _699767;
_699767 = 6.000000e+00f * _699766;
float _691820;
_691820 = *_691819;
float _699768;
_699768 = _699765 + _699767;
float _699769;
_699769 = _691820;
float _699770;
_699770 = 4.000000e+00f * _699769;
float _691826;
_691826 = *_691825;
float _699771;
_699771 = _699768 + _699770;
float _699772;
_699772 = _691826;
float _699773;
_699773 = _699771 + _699772;
float _691835;
_691835 = *_691834;
float _699774;
_699774 = 4.000000e+00f * _699773;
float _699776;
_699776 = _691835;
float _699775;
_699775 = _699761 + _699774;
float _691842;
_691842 = *_691841;
float _699777;
_699777 = _691842;
float _699778;
_699778 = 4.000000e+00f * _699777;
float _691849;
_691849 = *_691848;
float _699779;
_699779 = _699776 + _699778;
float _699780;
_699780 = _691849;
float _699781;
_699781 = 6.000000e+00f * _699780;
float _691855;
_691855 = *_691854;
float _699782;
_699782 = _699779 + _699781;
float _699783;
_699783 = _691855;
float _699784;
_699784 = 4.000000e+00f * _699783;
float _691861;
_691861 = *_691860;
float _699785;
_699785 = _699782 + _699784;
float _699786;
_699786 = _691861;
float _699787;
_699787 = _699785 + _699786;
float _691870;
_691870 = *_691869;
float _699788;
_699788 = 6.000000e+00f * _699787;
float _699790;
_699790 = _691870;
float _699789;
_699789 = _699775 + _699788;
float _691877;
_691877 = *_691876;
float _699791;
_699791 = _691877;
float _699792;
_699792 = 4.000000e+00f * _699791;
float _691884;
_691884 = *_691883;
float _699793;
_699793 = _699790 + _699792;
float _699794;
_699794 = _691884;
float _699795;
_699795 = 6.000000e+00f * _699794;
float _691890;
_691890 = *_691889;
float _699796;
_699796 = _699793 + _699795;
float _699797;
_699797 = _691890;
float _699798;
_699798 = 4.000000e+00f * _699797;
float _691896;
_691896 = *_691895;
float _699799;
_699799 = _699796 + _699798;
float _699800;
_699800 = _691896;
float _699801;
_699801 = _699799 + _699800;
float _691905;
_691905 = *_691904;
float _699802;
_699802 = 4.000000e+00f * _699801;
float _699804;
_699804 = _691905;
float _699803;
_699803 = _699789 + _699802;
float _691912;
_691912 = *_691911;
float _699805;
_699805 = _691912;
float _699806;
_699806 = 4.000000e+00f * _699805;
float _691919;
_691919 = *_691918;
float _699807;
_699807 = _699804 + _699806;
float _699808;
_699808 = _691919;
float _699809;
_699809 = 6.000000e+00f * _699808;
float _691925;
_691925 = *_691924;
float _699810;
_699810 = _699807 + _699809;
float _699811;
_699811 = _691925;
float _699812;
_699812 = 4.000000e+00f * _699811;
float _691931;
_691931 = *_691930;
float _699813;
_699813 = _699810 + _699812;
float _699814;
_699814 = _691931;
float _699815;
_699815 = _699813 + _699814;
float _691941;
_691941 = *_691940;
float _699816;
_699816 = _699803 + _699815;
float _699819;
_699819 = _691941;
float _699817;
_699817 = 6.000000e+00f * _699816;
float _691948;
_691948 = *_691947;
float _699818;
_699818 = _699749 + _699817;
float _699820;
_699820 = _691948;
float _699821;
_699821 = 4.000000e+00f * _699820;
float _691955;
_691955 = *_691954;
float _699822;
_699822 = _699819 + _699821;
float _699823;
_699823 = _691955;
float _699824;
_699824 = 6.000000e+00f * _699823;
float _691961;
_691961 = *_691960;
float _699825;
_699825 = _699822 + _699824;
float _699826;
_699826 = _691961;
float _699827;
_699827 = 4.000000e+00f * _699826;
float _691967;
_691967 = *_691966;
float _699828;
_699828 = _699825 + _699827;
float _699829;
_699829 = _691967;
float _699830;
_699830 = _699828 + _699829;
float _691976;
_691976 = *_691975;
float _699831;
_699831 = _691976;
float _691983;
_691983 = *_691982;
float _699832;
_699832 = _691983;
float _699833;
_699833 = 4.000000e+00f * _699832;
float _691990;
_691990 = *_691989;
float _699834;
_699834 = _699831 + _699833;
float _699835;
_699835 = _691990;
float _699836;
_699836 = 6.000000e+00f * _699835;
float _691996;
_691996 = *_691995;
float _699837;
_699837 = _699834 + _699836;
float _699838;
_699838 = _691996;
float _699839;
_699839 = 4.000000e+00f * _699838;
float _692002;
_692002 = *_692001;
float _699840;
_699840 = _699837 + _699839;
float _699841;
_699841 = _692002;
float _699842;
_699842 = _699840 + _699841;
float _692011;
_692011 = *_692010;
float _699843;
_699843 = 4.000000e+00f * _699842;
float _699845;
_699845 = _692011;
float _699844;
_699844 = _699830 + _699843;
float _692018;
_692018 = *_692017;
float _699846;
_699846 = _692018;
float _699847;
_699847 = 4.000000e+00f * _699846;
float _692025;
_692025 = *_692024;
float _699848;
_699848 = _699845 + _699847;
float _699849;
_699849 = _692025;
float _699850;
_699850 = 6.000000e+00f * _699849;
float _692031;
_692031 = *_692030;
float _699851;
_699851 = _699848 + _699850;
float _699852;
_699852 = _692031;
float _699853;
_699853 = 4.000000e+00f * _699852;
float _692037;
_692037 = *_692036;
float _699854;
_699854 = _699851 + _699853;
float _699855;
_699855 = _692037;
float _699856;
_699856 = _699854 + _699855;
float _692046;
_692046 = *_692045;
float _699857;
_699857 = 6.000000e+00f * _699856;
float _699859;
_699859 = _692046;
float _699858;
_699858 = _699844 + _699857;
float _692053;
_692053 = *_692052;
float _699860;
_699860 = _692053;
float _699861;
_699861 = 4.000000e+00f * _699860;
float _692060;
_692060 = *_692059;
float _699862;
_699862 = _699859 + _699861;
float _699863;
_699863 = _692060;
float _699864;
_699864 = 6.000000e+00f * _699863;
float _692066;
_692066 = *_692065;
float _699865;
_699865 = _699862 + _699864;
float _699866;
_699866 = _692066;
float _699867;
_699867 = 4.000000e+00f * _699866;
float _692072;
_692072 = *_692071;
float _699868;
_699868 = _699865 + _699867;
float _699869;
_699869 = _692072;
float _699870;
_699870 = _699868 + _699869;
float _692081;
_692081 = *_692080;
float _699871;
_699871 = 4.000000e+00f * _699870;
float _699873;
_699873 = _692081;
float _699872;
_699872 = _699858 + _699871;
float _692088;
_692088 = *_692087;
float _699874;
_699874 = _692088;
float _699875;
_699875 = 4.000000e+00f * _699874;
float _692095;
_692095 = *_692094;
float _699876;
_699876 = _699873 + _699875;
float _699877;
_699877 = _692095;
float _699878;
_699878 = 6.000000e+00f * _699877;
float _692101;
_692101 = *_692100;
float _699879;
_699879 = _699876 + _699878;
float _699880;
_699880 = _692101;
float _699881;
_699881 = 4.000000e+00f * _699880;
float _692107;
_692107 = *_692106;
float _699882;
_699882 = _699879 + _699881;
float _699883;
_699883 = _692107;
float _699884;
_699884 = _699882 + _699883;
float _692117;
_692117 = *_692116;
float _699885;
_699885 = _699872 + _699884;
float _699888;
_699888 = _692117;
float _699886;
_699886 = 4.000000e+00f * _699885;
float _692124;
_692124 = *_692123;
float _699887;
_699887 = _699818 + _699886;
float _699889;
_699889 = _692124;
float _699890;
_699890 = 4.000000e+00f * _699889;
float _692131;
_692131 = *_692130;
float _699891;
_699891 = _699888 + _699890;
float _699892;
_699892 = _692131;
float _699893;
_699893 = 6.000000e+00f * _699892;
float _692137;
_692137 = *_692136;
float _699894;
_699894 = _699891 + _699893;
float _699895;
_699895 = _692137;
float _699896;
_699896 = 4.000000e+00f * _699895;
float _692143;
_692143 = *_692142;
float _699897;
_699897 = _699894 + _699896;
float _699898;
_699898 = _692143;
float _699899;
_699899 = _699897 + _699898;
float _692152;
_692152 = *_692151;
float _699900;
_699900 = _692152;
float _692159;
_692159 = *_692158;
float _699901;
_699901 = _692159;
float _699902;
_699902 = 4.000000e+00f * _699901;
float _692166;
_692166 = *_692165;
float _699903;
_699903 = _699900 + _699902;
float _699904;
_699904 = _692166;
float _699905;
_699905 = 6.000000e+00f * _699904;
float _692172;
_692172 = *_692171;
float _699906;
_699906 = _699903 + _699905;
float _699907;
_699907 = _692172;
float _699908;
_699908 = 4.000000e+00f * _699907;
float _692178;
_692178 = *_692177;
float _699909;
_699909 = _699906 + _699908;
float _699910;
_699910 = _692178;
float _699911;
_699911 = _699909 + _699910;
float _692187;
_692187 = *_692186;
float _699912;
_699912 = 4.000000e+00f * _699911;
float _699914;
_699914 = _692187;
float _699913;
_699913 = _699899 + _699912;
float _692194;
_692194 = *_692193;
float _699915;
_699915 = _692194;
float _699916;
_699916 = 4.000000e+00f * _699915;
float _692201;
_692201 = *_692200;
float _699917;
_699917 = _699914 + _699916;
float _699918;
_699918 = _692201;
float _699919;
_699919 = 6.000000e+00f * _699918;
float _692207;
_692207 = *_692206;
float _699920;
_699920 = _699917 + _699919;
float _699921;
_699921 = _692207;
float _699922;
_699922 = 4.000000e+00f * _699921;
float _692213;
_692213 = *_692212;
float _699923;
_699923 = _699920 + _699922;
float _699924;
_699924 = _692213;
float _699925;
_699925 = _699923 + _699924;
float _692222;
_692222 = *_692221;
float _699926;
_699926 = 6.000000e+00f * _699925;
float _699928;
_699928 = _692222;
float _699927;
_699927 = _699913 + _699926;
float _692229;
_692229 = *_692228;
float _699929;
_699929 = _692229;
float _699930;
_699930 = 4.000000e+00f * _699929;
float _692236;
_692236 = *_692235;
float _699931;
_699931 = _699928 + _699930;
float _699932;
_699932 = _692236;
float _699933;
_699933 = 6.000000e+00f * _699932;
float _692242;
_692242 = *_692241;
float _699934;
_699934 = _699931 + _699933;
float _699935;
_699935 = _692242;
float _699936;
_699936 = 4.000000e+00f * _699935;
float _692248;
_692248 = *_692247;
float _699937;
_699937 = _699934 + _699936;
float _699938;
_699938 = _692248;
float _699939;
_699939 = _699937 + _699938;
float _692257;
_692257 = *_692256;
float _699940;
_699940 = 4.000000e+00f * _699939;
float _699942;
_699942 = _692257;
float _699941;
_699941 = _699927 + _699940;
float _692264;
_692264 = *_692263;
float _699943;
_699943 = _692264;
float _699944;
_699944 = 4.000000e+00f * _699943;
float _692271;
_692271 = *_692270;
float _699945;
_699945 = _699942 + _699944;
float _699946;
_699946 = _692271;
float _699947;
_699947 = 6.000000e+00f * _699946;
float _692277;
_692277 = *_692276;
float _699948;
_699948 = _699945 + _699947;
float _699949;
_699949 = _692277;
float _699950;
_699950 = 4.000000e+00f * _699949;
float _692283;
_692283 = *_692282;
float _699951;
_699951 = _699948 + _699950;
float _699952;
_699952 = _692283;
float _699953;
_699953 = _699951 + _699952;
float _692295;
_692295 = *_692294;
float _699954;
_699954 = _699941 + _699953;
float _699961;
_699961 = _692295;
float _699955;
_699955 = _699887 + _699954;
float _692303;
_692303 = *_692302;
float _699956;
_699956 = xf_695819 * _699955;
float _699962;
_699962 = _692303;
float _699957;
_699957 = _699613 + _699956;
float _699963;
_699963 = 4.000000e+00f * _699962;
float _692310;
_692310 = *_692309;
float _699958;
_699958 = yf_695815 * _699957;
float _699964;
_699964 = _699961 + _699963;
float _699965;
_699965 = _692310;
float _699959;
_699959 = _699270 + _699958;
float _699966;
_699966 = 6.000000e+00f * _699965;
float _692316;
_692316 = *_692315;
float _699960;
_699960 = _698582 * _699959;
float _699967;
_699967 = _699964 + _699966;
float _699968;
_699968 = _692316;
float _699969;
_699969 = 4.000000e+00f * _699968;
float _692322;
_692322 = *_692321;
float _699970;
_699970 = _699967 + _699969;
float _699971;
_699971 = _692322;
float _699972;
_699972 = _699970 + _699971;
float _692331;
_692331 = *_692330;
float _699973;
_699973 = _692331;
float _692338;
_692338 = *_692337;
float _699974;
_699974 = _692338;
float _699975;
_699975 = 4.000000e+00f * _699974;
float _692345;
_692345 = *_692344;
float _699976;
_699976 = _699973 + _699975;
float _699977;
_699977 = _692345;
float _699978;
_699978 = 6.000000e+00f * _699977;
float _692351;
_692351 = *_692350;
float _699979;
_699979 = _699976 + _699978;
float _699980;
_699980 = _692351;
float _699981;
_699981 = 4.000000e+00f * _699980;
float _692357;
_692357 = *_692356;
float _699982;
_699982 = _699979 + _699981;
float _699983;
_699983 = _692357;
float _699984;
_699984 = _699982 + _699983;
float _692366;
_692366 = *_692365;
float _699985;
_699985 = 4.000000e+00f * _699984;
float _699987;
_699987 = _692366;
float _699986;
_699986 = _699972 + _699985;
float _692373;
_692373 = *_692372;
float _699988;
_699988 = _692373;
float _699989;
_699989 = 4.000000e+00f * _699988;
float _692380;
_692380 = *_692379;
float _699990;
_699990 = _699987 + _699989;
float _699991;
_699991 = _692380;
float _699992;
_699992 = 6.000000e+00f * _699991;
float _692386;
_692386 = *_692385;
float _699993;
_699993 = _699990 + _699992;
float _699994;
_699994 = _692386;
float _699995;
_699995 = 4.000000e+00f * _699994;
float _692392;
_692392 = *_692391;
float _699996;
_699996 = _699993 + _699995;
float _699997;
_699997 = _692392;
float _699998;
_699998 = _699996 + _699997;
float _692401;
_692401 = *_692400;
float _699999;
_699999 = 6.000000e+00f * _699998;
float _700001;
_700001 = _692401;
float _700000;
_700000 = _699986 + _699999;
float _692408;
_692408 = *_692407;
float _700002;
_700002 = _692408;
float _700003;
_700003 = 4.000000e+00f * _700002;
float _692415;
_692415 = *_692414;
float _700004;
_700004 = _700001 + _700003;
float _700005;
_700005 = _692415;
float _700006;
_700006 = 6.000000e+00f * _700005;
float _692421;
_692421 = *_692420;
float _700007;
_700007 = _700004 + _700006;
float _700008;
_700008 = _692421;
float _700009;
_700009 = 4.000000e+00f * _700008;
float _692427;
_692427 = *_692426;
float _700010;
_700010 = _700007 + _700009;
float _700011;
_700011 = _692427;
float _700012;
_700012 = _700010 + _700011;
float _692436;
_692436 = *_692435;
float _700013;
_700013 = 4.000000e+00f * _700012;
float _700015;
_700015 = _692436;
float _700014;
_700014 = _700000 + _700013;
float _692443;
_692443 = *_692442;
float _700016;
_700016 = _692443;
float _700017;
_700017 = 4.000000e+00f * _700016;
float _692450;
_692450 = *_692449;
float _700018;
_700018 = _700015 + _700017;
float _700019;
_700019 = _692450;
float _700020;
_700020 = 6.000000e+00f * _700019;
float _692456;
_692456 = *_692455;
float _700021;
_700021 = _700018 + _700020;
float _700022;
_700022 = _692456;
float _700023;
_700023 = 4.000000e+00f * _700022;
float _692462;
_692462 = *_692461;
float _700024;
_700024 = _700021 + _700023;
float _700025;
_700025 = _692462;
float _700026;
_700026 = _700024 + _700025;
float _692472;
_692472 = *_692471;
float _700027;
_700027 = _700014 + _700026;
float _700028;
_700028 = _692472;
float _692479;
_692479 = *_692478;
float _700029;
_700029 = _692479;
float _700030;
_700030 = 4.000000e+00f * _700029;
float _692486;
_692486 = *_692485;
float _700031;
_700031 = _700028 + _700030;
float _700032;
_700032 = _692486;
float _700033;
_700033 = 6.000000e+00f * _700032;
float _692492;
_692492 = *_692491;
float _700034;
_700034 = _700031 + _700033;
float _700035;
_700035 = _692492;
float _700036;
_700036 = 4.000000e+00f * _700035;
float _692498;
_692498 = *_692497;
float _700037;
_700037 = _700034 + _700036;
float _700038;
_700038 = _692498;
float _700039;
_700039 = _700037 + _700038;
float _692507;
_692507 = *_692506;
float _700040;
_700040 = _692507;
float _692514;
_692514 = *_692513;
float _700041;
_700041 = _692514;
float _700042;
_700042 = 4.000000e+00f * _700041;
float _692521;
_692521 = *_692520;
float _700043;
_700043 = _700040 + _700042;
float _700044;
_700044 = _692521;
float _700045;
_700045 = 6.000000e+00f * _700044;
float _692527;
_692527 = *_692526;
float _700046;
_700046 = _700043 + _700045;
float _700047;
_700047 = _692527;
float _700048;
_700048 = 4.000000e+00f * _700047;
float _692533;
_692533 = *_692532;
float _700049;
_700049 = _700046 + _700048;
float _700050;
_700050 = _692533;
float _700051;
_700051 = _700049 + _700050;
float _692542;
_692542 = *_692541;
float _700052;
_700052 = 4.000000e+00f * _700051;
float _700054;
_700054 = _692542;
float _700053;
_700053 = _700039 + _700052;
float _692549;
_692549 = *_692548;
float _700055;
_700055 = _692549;
float _700056;
_700056 = 4.000000e+00f * _700055;
float _692556;
_692556 = *_692555;
float _700057;
_700057 = _700054 + _700056;
float _700058;
_700058 = _692556;
float _700059;
_700059 = 6.000000e+00f * _700058;
float _692562;
_692562 = *_692561;
float _700060;
_700060 = _700057 + _700059;
float _700061;
_700061 = _692562;
float _700062;
_700062 = 4.000000e+00f * _700061;
float _692568;
_692568 = *_692567;
float _700063;
_700063 = _700060 + _700062;
float _700064;
_700064 = _692568;
float _700065;
_700065 = _700063 + _700064;
float _692577;
_692577 = *_692576;
float _700066;
_700066 = 6.000000e+00f * _700065;
float _700068;
_700068 = _692577;
float _700067;
_700067 = _700053 + _700066;
float _692584;
_692584 = *_692583;
float _700069;
_700069 = _692584;
float _700070;
_700070 = 4.000000e+00f * _700069;
float _692591;
_692591 = *_692590;
float _700071;
_700071 = _700068 + _700070;
float _700072;
_700072 = _692591;
float _700073;
_700073 = 6.000000e+00f * _700072;
float _692597;
_692597 = *_692596;
float _700074;
_700074 = _700071 + _700073;
float _700075;
_700075 = _692597;
float _700076;
_700076 = 4.000000e+00f * _700075;
float _692603;
_692603 = *_692602;
float _700077;
_700077 = _700074 + _700076;
float _700078;
_700078 = _692603;
float _700079;
_700079 = _700077 + _700078;
float _692612;
_692612 = *_692611;
float _700080;
_700080 = 4.000000e+00f * _700079;
float _700082;
_700082 = _692612;
float _700081;
_700081 = _700067 + _700080;
float _692619;
_692619 = *_692618;
float _700083;
_700083 = _692619;
float _700084;
_700084 = 4.000000e+00f * _700083;
float _692626;
_692626 = *_692625;
float _700085;
_700085 = _700082 + _700084;
float _700086;
_700086 = _692626;
float _700087;
_700087 = 6.000000e+00f * _700086;
float _692632;
_692632 = *_692631;
float _700088;
_700088 = _700085 + _700087;
float _700089;
_700089 = _692632;
float _700090;
_700090 = 4.000000e+00f * _700089;
float _692638;
_692638 = *_692637;
float _700091;
_700091 = _700088 + _700090;
float _700092;
_700092 = _692638;
float _700093;
_700093 = _700091 + _700092;
float _692648;
_692648 = *_692647;
float _700094;
_700094 = _700081 + _700093;
float _700097;
_700097 = _692648;
float _700095;
_700095 = 4.000000e+00f * _700094;
float _692655;
_692655 = *_692654;
float _700096;
_700096 = _700027 + _700095;
float _700098;
_700098 = _692655;
float _700099;
_700099 = 4.000000e+00f * _700098;
float _692662;
_692662 = *_692661;
float _700100;
_700100 = _700097 + _700099;
float _700101;
_700101 = _692662;
float _700102;
_700102 = 6.000000e+00f * _700101;
float _692668;
_692668 = *_692667;
float _700103;
_700103 = _700100 + _700102;
float _700104;
_700104 = _692668;
float _700105;
_700105 = 4.000000e+00f * _700104;
float _692674;
_692674 = *_692673;
float _700106;
_700106 = _700103 + _700105;
float _700107;
_700107 = _692674;
float _700108;
_700108 = _700106 + _700107;
float _692683;
_692683 = *_692682;
float _700109;
_700109 = _692683;
float _692690;
_692690 = *_692689;
float _700110;
_700110 = _692690;
float _700111;
_700111 = 4.000000e+00f * _700110;
float _692697;
_692697 = *_692696;
float _700112;
_700112 = _700109 + _700111;
float _700113;
_700113 = _692697;
float _700114;
_700114 = 6.000000e+00f * _700113;
float _692703;
_692703 = *_692702;
float _700115;
_700115 = _700112 + _700114;
float _700116;
_700116 = _692703;
float _700117;
_700117 = 4.000000e+00f * _700116;
float _692709;
_692709 = *_692708;
float _700118;
_700118 = _700115 + _700117;
float _700119;
_700119 = _692709;
float _700120;
_700120 = _700118 + _700119;
float _692718;
_692718 = *_692717;
float _700121;
_700121 = 4.000000e+00f * _700120;
float _700123;
_700123 = _692718;
float _700122;
_700122 = _700108 + _700121;
float _692725;
_692725 = *_692724;
float _700124;
_700124 = _692725;
float _700125;
_700125 = 4.000000e+00f * _700124;
float _692732;
_692732 = *_692731;
float _700126;
_700126 = _700123 + _700125;
float _700127;
_700127 = _692732;
float _700128;
_700128 = 6.000000e+00f * _700127;
float _692738;
_692738 = *_692737;
float _700129;
_700129 = _700126 + _700128;
float _700130;
_700130 = _692738;
float _700131;
_700131 = 4.000000e+00f * _700130;
float _692744;
_692744 = *_692743;
float _700132;
_700132 = _700129 + _700131;
float _700133;
_700133 = _692744;
float _700134;
_700134 = _700132 + _700133;
float _692753;
_692753 = *_692752;
float _700135;
_700135 = 6.000000e+00f * _700134;
float _700137;
_700137 = _692753;
float _700136;
_700136 = _700122 + _700135;
float _692760;
_692760 = *_692759;
float _700138;
_700138 = _692760;
float _700139;
_700139 = 4.000000e+00f * _700138;
float _692767;
_692767 = *_692766;
float _700140;
_700140 = _700137 + _700139;
float _700141;
_700141 = _692767;
float _700142;
_700142 = 6.000000e+00f * _700141;
float _692773;
_692773 = *_692772;
float _700143;
_700143 = _700140 + _700142;
float _700144;
_700144 = _692773;
float _700145;
_700145 = 4.000000e+00f * _700144;
float _692779;
_692779 = *_692778;
float _700146;
_700146 = _700143 + _700145;
float _700147;
_700147 = _692779;
float _700148;
_700148 = _700146 + _700147;
float _692788;
_692788 = *_692787;
float _700149;
_700149 = 4.000000e+00f * _700148;
float _700151;
_700151 = _692788;
float _700150;
_700150 = _700136 + _700149;
float _692795;
_692795 = *_692794;
float _700152;
_700152 = _692795;
float _700153;
_700153 = 4.000000e+00f * _700152;
float _692802;
_692802 = *_692801;
float _700154;
_700154 = _700151 + _700153;
float _700155;
_700155 = _692802;
float _700156;
_700156 = 6.000000e+00f * _700155;
float _692808;
_692808 = *_692807;
float _700157;
_700157 = _700154 + _700156;
float _700158;
_700158 = _692808;
float _700159;
_700159 = 4.000000e+00f * _700158;
float _692814;
_692814 = *_692813;
float _700160;
_700160 = _700157 + _700159;
float _700161;
_700161 = _692814;
float _700162;
_700162 = _700160 + _700161;
float _692824;
_692824 = *_692823;
float _700163;
_700163 = _700150 + _700162;
float _700166;
_700166 = _692824;
float _700164;
_700164 = 6.000000e+00f * _700163;
float _692831;
_692831 = *_692830;
float _700165;
_700165 = _700096 + _700164;
float _700167;
_700167 = _692831;
float _700168;
_700168 = 4.000000e+00f * _700167;
float _692838;
_692838 = *_692837;
float _700169;
_700169 = _700166 + _700168;
float _700170;
_700170 = _692838;
float _700171;
_700171 = 6.000000e+00f * _700170;
float _692844;
_692844 = *_692843;
float _700172;
_700172 = _700169 + _700171;
float _700173;
_700173 = _692844;
float _700174;
_700174 = 4.000000e+00f * _700173;
float _692850;
_692850 = *_692849;
float _700175;
_700175 = _700172 + _700174;
float _700176;
_700176 = _692850;
float _700177;
_700177 = _700175 + _700176;
float _692859;
_692859 = *_692858;
float _700178;
_700178 = _692859;
float _692866;
_692866 = *_692865;
float _700179;
_700179 = _692866;
float _700180;
_700180 = 4.000000e+00f * _700179;
float _692873;
_692873 = *_692872;
float _700181;
_700181 = _700178 + _700180;
float _700182;
_700182 = _692873;
float _700183;
_700183 = 6.000000e+00f * _700182;
float _692879;
_692879 = *_692878;
float _700184;
_700184 = _700181 + _700183;
float _700185;
_700185 = _692879;
float _700186;
_700186 = 4.000000e+00f * _700185;
float _692885;
_692885 = *_692884;
float _700187;
_700187 = _700184 + _700186;
float _700188;
_700188 = _692885;
float _700189;
_700189 = _700187 + _700188;
float _692894;
_692894 = *_692893;
float _700190;
_700190 = 4.000000e+00f * _700189;
float _700192;
_700192 = _692894;
float _700191;
_700191 = _700177 + _700190;
float _692901;
_692901 = *_692900;
float _700193;
_700193 = _692901;
float _700194;
_700194 = 4.000000e+00f * _700193;
float _692908;
_692908 = *_692907;
float _700195;
_700195 = _700192 + _700194;
float _700196;
_700196 = _692908;
float _700197;
_700197 = 6.000000e+00f * _700196;
float _692914;
_692914 = *_692913;
float _700198;
_700198 = _700195 + _700197;
float _700199;
_700199 = _692914;
float _700200;
_700200 = 4.000000e+00f * _700199;
float _692920;
_692920 = *_692919;
float _700201;
_700201 = _700198 + _700200;
float _700202;
_700202 = _692920;
float _700203;
_700203 = _700201 + _700202;
float _692929;
_692929 = *_692928;
float _700204;
_700204 = 6.000000e+00f * _700203;
float _700206;
_700206 = _692929;
float _700205;
_700205 = _700191 + _700204;
float _692936;
_692936 = *_692935;
float _700207;
_700207 = _692936;
float _700208;
_700208 = 4.000000e+00f * _700207;
float _692943;
_692943 = *_692942;
float _700209;
_700209 = _700206 + _700208;
float _700210;
_700210 = _692943;
float _700211;
_700211 = 6.000000e+00f * _700210;
float _692949;
_692949 = *_692948;
float _700212;
_700212 = _700209 + _700211;
float _700213;
_700213 = _692949;
float _700214;
_700214 = 4.000000e+00f * _700213;
float _692955;
_692955 = *_692954;
float _700215;
_700215 = _700212 + _700214;
float _700216;
_700216 = _692955;
float _700217;
_700217 = _700215 + _700216;
float _692964;
_692964 = *_692963;
float _700218;
_700218 = 4.000000e+00f * _700217;
float _700220;
_700220 = _692964;
float _700219;
_700219 = _700205 + _700218;
float _692971;
_692971 = *_692970;
float _700221;
_700221 = _692971;
float _700222;
_700222 = 4.000000e+00f * _700221;
float _692978;
_692978 = *_692977;
float _700223;
_700223 = _700220 + _700222;
float _700224;
_700224 = _692978;
float _700225;
_700225 = 6.000000e+00f * _700224;
float _692984;
_692984 = *_692983;
float _700226;
_700226 = _700223 + _700225;
float _700227;
_700227 = _692984;
float _700228;
_700228 = 4.000000e+00f * _700227;
float _692990;
_692990 = *_692989;
float _700229;
_700229 = _700226 + _700228;
float _700230;
_700230 = _692990;
float _700231;
_700231 = _700229 + _700230;
float _693000;
_693000 = *_692999;
float _700232;
_700232 = _700219 + _700231;
float _700235;
_700235 = _693000;
float _700233;
_700233 = 4.000000e+00f * _700232;
float _693007;
_693007 = *_693006;
float _700234;
_700234 = _700165 + _700233;
float _700236;
_700236 = _693007;
float _700237;
_700237 = 4.000000e+00f * _700236;
float _693014;
_693014 = *_693013;
float _700238;
_700238 = _700235 + _700237;
float _700239;
_700239 = _693014;
float _700240;
_700240 = 6.000000e+00f * _700239;
float _693020;
_693020 = *_693019;
float _700241;
_700241 = _700238 + _700240;
float _700242;
_700242 = _693020;
float _700243;
_700243 = 4.000000e+00f * _700242;
float _693026;
_693026 = *_693025;
float _700244;
_700244 = _700241 + _700243;
float _700245;
_700245 = _693026;
float _700246;
_700246 = _700244 + _700245;
float _693035;
_693035 = *_693034;
float _700247;
_700247 = _693035;
float _693042;
_693042 = *_693041;
float _700248;
_700248 = _693042;
float _700249;
_700249 = 4.000000e+00f * _700248;
float _693049;
_693049 = *_693048;
float _700250;
_700250 = _700247 + _700249;
float _700251;
_700251 = _693049;
float _700252;
_700252 = 6.000000e+00f * _700251;
float _693055;
_693055 = *_693054;
float _700253;
_700253 = _700250 + _700252;
float _700254;
_700254 = _693055;
float _700255;
_700255 = 4.000000e+00f * _700254;
float _693061;
_693061 = *_693060;
float _700256;
_700256 = _700253 + _700255;
float _700257;
_700257 = _693061;
float _700258;
_700258 = _700256 + _700257;
float _693070;
_693070 = *_693069;
float _700259;
_700259 = 4.000000e+00f * _700258;
float _700261;
_700261 = _693070;
float _700260;
_700260 = _700246 + _700259;
float _693077;
_693077 = *_693076;
float _700262;
_700262 = _693077;
float _700263;
_700263 = 4.000000e+00f * _700262;
float _693084;
_693084 = *_693083;
float _700264;
_700264 = _700261 + _700263;
float _700265;
_700265 = _693084;
float _700266;
_700266 = 6.000000e+00f * _700265;
float _693090;
_693090 = *_693089;
float _700267;
_700267 = _700264 + _700266;
float _700268;
_700268 = _693090;
float _700269;
_700269 = 4.000000e+00f * _700268;
float _693096;
_693096 = *_693095;
float _700270;
_700270 = _700267 + _700269;
float _700271;
_700271 = _693096;
float _700272;
_700272 = _700270 + _700271;
float _693105;
_693105 = *_693104;
float _700273;
_700273 = 6.000000e+00f * _700272;
float _700275;
_700275 = _693105;
float _700274;
_700274 = _700260 + _700273;
float _693112;
_693112 = *_693111;
float _700276;
_700276 = _693112;
float _700277;
_700277 = 4.000000e+00f * _700276;
float _693119;
_693119 = *_693118;
float _700278;
_700278 = _700275 + _700277;
float _700279;
_700279 = _693119;
float _700280;
_700280 = 6.000000e+00f * _700279;
float _693125;
_693125 = *_693124;
float _700281;
_700281 = _700278 + _700280;
float _700282;
_700282 = _693125;
float _700283;
_700283 = 4.000000e+00f * _700282;
float _693131;
_693131 = *_693130;
float _700284;
_700284 = _700281 + _700283;
float _700285;
_700285 = _693131;
float _700286;
_700286 = _700284 + _700285;
float _693140;
_693140 = *_693139;
float _700287;
_700287 = 4.000000e+00f * _700286;
float _700289;
_700289 = _693140;
float _700288;
_700288 = _700274 + _700287;
float _693147;
_693147 = *_693146;
float _700290;
_700290 = _693147;
float _700291;
_700291 = 4.000000e+00f * _700290;
float _693154;
_693154 = *_693153;
float _700292;
_700292 = _700289 + _700291;
float _700293;
_700293 = _693154;
float _700294;
_700294 = 6.000000e+00f * _700293;
float _693160;
_693160 = *_693159;
float _700295;
_700295 = _700292 + _700294;
float _700296;
_700296 = _693160;
float _700297;
_700297 = 4.000000e+00f * _700296;
float _693166;
_693166 = *_693165;
float _700298;
_700298 = _700295 + _700297;
float _700299;
_700299 = _693166;
float _700300;
_700300 = _700298 + _700299;
float _693176;
_693176 = *_693175;
float _700301;
_700301 = _700288 + _700300;
float _700304;
_700304 = _693176;
float _700302;
_700302 = _700234 + _700301;
float _693183;
_693183 = *_693182;
float _700303;
_700303 = _695820 * _700302;
float _700305;
_700305 = _693183;
float _700306;
_700306 = 4.000000e+00f * _700305;
float _693190;
_693190 = *_693189;
float _700307;
_700307 = _700304 + _700306;
float _700308;
_700308 = _693190;
float _700309;
_700309 = 6.000000e+00f * _700308;
float _693196;
_693196 = *_693195;
float _700310;
_700310 = _700307 + _700309;
float _700311;
_700311 = _693196;
float _700312;
_700312 = 4.000000e+00f * _700311;
float _693202;
_693202 = *_693201;
float _700313;
_700313 = _700310 + _700312;
float _700314;
_700314 = _693202;
float _700315;
_700315 = _700313 + _700314;
float _693211;
_693211 = *_693210;
float _700316;
_700316 = _693211;
float _693218;
_693218 = *_693217;
float _700317;
_700317 = _693218;
float _700318;
_700318 = 4.000000e+00f * _700317;
float _693225;
_693225 = *_693224;
float _700319;
_700319 = _700316 + _700318;
float _700320;
_700320 = _693225;
float _700321;
_700321 = 6.000000e+00f * _700320;
float _693231;
_693231 = *_693230;
float _700322;
_700322 = _700319 + _700321;
float _700323;
_700323 = _693231;
float _700324;
_700324 = 4.000000e+00f * _700323;
float _693237;
_693237 = *_693236;
float _700325;
_700325 = _700322 + _700324;
float _700326;
_700326 = _693237;
float _700327;
_700327 = _700325 + _700326;
float _693246;
_693246 = *_693245;
float _700328;
_700328 = 4.000000e+00f * _700327;
float _700330;
_700330 = _693246;
float _700329;
_700329 = _700315 + _700328;
float _693253;
_693253 = *_693252;
float _700331;
_700331 = _693253;
float _700332;
_700332 = 4.000000e+00f * _700331;
float _693260;
_693260 = *_693259;
float _700333;
_700333 = _700330 + _700332;
float _700334;
_700334 = _693260;
float _700335;
_700335 = 6.000000e+00f * _700334;
float _693266;
_693266 = *_693265;
float _700336;
_700336 = _700333 + _700335;
float _700337;
_700337 = _693266;
float _700338;
_700338 = 4.000000e+00f * _700337;
float _693272;
_693272 = *_693271;
float _700339;
_700339 = _700336 + _700338;
float _700340;
_700340 = _693272;
float _700341;
_700341 = _700339 + _700340;
float _693281;
_693281 = *_693280;
float _700342;
_700342 = 6.000000e+00f * _700341;
float _700344;
_700344 = _693281;
float _700343;
_700343 = _700329 + _700342;
float _693288;
_693288 = *_693287;
float _700345;
_700345 = _693288;
float _700346;
_700346 = 4.000000e+00f * _700345;
float _693295;
_693295 = *_693294;
float _700347;
_700347 = _700344 + _700346;
float _700348;
_700348 = _693295;
float _700349;
_700349 = 6.000000e+00f * _700348;
float _693301;
_693301 = *_693300;
float _700350;
_700350 = _700347 + _700349;
float _700351;
_700351 = _693301;
float _700352;
_700352 = 4.000000e+00f * _700351;
float _693307;
_693307 = *_693306;
float _700353;
_700353 = _700350 + _700352;
float _700354;
_700354 = _693307;
float _700355;
_700355 = _700353 + _700354;
float _693316;
_693316 = *_693315;
float _700356;
_700356 = 4.000000e+00f * _700355;
float _700358;
_700358 = _693316;
float _700357;
_700357 = _700343 + _700356;
float _693323;
_693323 = *_693322;
float _700359;
_700359 = _693323;
float _700360;
_700360 = 4.000000e+00f * _700359;
float _693330;
_693330 = *_693329;
float _700361;
_700361 = _700358 + _700360;
float _700362;
_700362 = _693330;
float _700363;
_700363 = 6.000000e+00f * _700362;
float _693336;
_693336 = *_693335;
float _700364;
_700364 = _700361 + _700363;
float _700365;
_700365 = _693336;
float _700366;
_700366 = 4.000000e+00f * _700365;
float _693342;
_693342 = *_693341;
float _700367;
_700367 = _700364 + _700366;
float _700368;
_700368 = _693342;
float _700369;
_700369 = _700367 + _700368;
float _693352;
_693352 = *_693351;
float _700370;
_700370 = _700357 + _700369;
float _700371;
_700371 = _693352;
float _693359;
_693359 = *_693358;
float _700372;
_700372 = _693359;
float _700373;
_700373 = 4.000000e+00f * _700372;
float _693366;
_693366 = *_693365;
float _700374;
_700374 = _700371 + _700373;
float _700375;
_700375 = _693366;
float _700376;
_700376 = 6.000000e+00f * _700375;
float _693372;
_693372 = *_693371;
float _700377;
_700377 = _700374 + _700376;
float _700378;
_700378 = _693372;
float _700379;
_700379 = 4.000000e+00f * _700378;
float _693378;
_693378 = *_693377;
float _700380;
_700380 = _700377 + _700379;
float _700381;
_700381 = _693378;
float _700382;
_700382 = _700380 + _700381;
float _693387;
_693387 = *_693386;
float _700383;
_700383 = _693387;
float _693394;
_693394 = *_693393;
float _700384;
_700384 = _693394;
float _700385;
_700385 = 4.000000e+00f * _700384;
float _693401;
_693401 = *_693400;
float _700386;
_700386 = _700383 + _700385;
float _700387;
_700387 = _693401;
float _700388;
_700388 = 6.000000e+00f * _700387;
float _693407;
_693407 = *_693406;
float _700389;
_700389 = _700386 + _700388;
float _700390;
_700390 = _693407;
float _700391;
_700391 = 4.000000e+00f * _700390;
float _693413;
_693413 = *_693412;
float _700392;
_700392 = _700389 + _700391;
float _700393;
_700393 = _693413;
float _700394;
_700394 = _700392 + _700393;
float _693422;
_693422 = *_693421;
float _700395;
_700395 = 4.000000e+00f * _700394;
float _700397;
_700397 = _693422;
float _700396;
_700396 = _700382 + _700395;
float _693429;
_693429 = *_693428;
float _700398;
_700398 = _693429;
float _700399;
_700399 = 4.000000e+00f * _700398;
float _693436;
_693436 = *_693435;
float _700400;
_700400 = _700397 + _700399;
float _700401;
_700401 = _693436;
float _700402;
_700402 = 6.000000e+00f * _700401;
float _693442;
_693442 = *_693441;
float _700403;
_700403 = _700400 + _700402;
float _700404;
_700404 = _693442;
float _700405;
_700405 = 4.000000e+00f * _700404;
float _693448;
_693448 = *_693447;
float _700406;
_700406 = _700403 + _700405;
float _700407;
_700407 = _693448;
float _700408;
_700408 = _700406 + _700407;
float _693457;
_693457 = *_693456;
float _700409;
_700409 = 6.000000e+00f * _700408;
float _700411;
_700411 = _693457;
float _700410;
_700410 = _700396 + _700409;
float _693464;
_693464 = *_693463;
float _700412;
_700412 = _693464;
float _700413;
_700413 = 4.000000e+00f * _700412;
float _693471;
_693471 = *_693470;
float _700414;
_700414 = _700411 + _700413;
float _700415;
_700415 = _693471;
float _700416;
_700416 = 6.000000e+00f * _700415;
float _693477;
_693477 = *_693476;
float _700417;
_700417 = _700414 + _700416;
float _700418;
_700418 = _693477;
float _700419;
_700419 = 4.000000e+00f * _700418;
float _693483;
_693483 = *_693482;
float _700420;
_700420 = _700417 + _700419;
float _700421;
_700421 = _693483;
float _700422;
_700422 = _700420 + _700421;
float _693492;
_693492 = *_693491;
float _700423;
_700423 = 4.000000e+00f * _700422;
float _700425;
_700425 = _693492;
float _700424;
_700424 = _700410 + _700423;
float _693499;
_693499 = *_693498;
float _700426;
_700426 = _693499;
float _700427;
_700427 = 4.000000e+00f * _700426;
float _693506;
_693506 = *_693505;
float _700428;
_700428 = _700425 + _700427;
float _700429;
_700429 = _693506;
float _700430;
_700430 = 6.000000e+00f * _700429;
float _693512;
_693512 = *_693511;
float _700431;
_700431 = _700428 + _700430;
float _700432;
_700432 = _693512;
float _700433;
_700433 = 4.000000e+00f * _700432;
float _693518;
_693518 = *_693517;
float _700434;
_700434 = _700431 + _700433;
float _700435;
_700435 = _693518;
float _700436;
_700436 = _700434 + _700435;
float _693528;
_693528 = *_693527;
float _700437;
_700437 = _700424 + _700436;
float _700440;
_700440 = _693528;
float _700438;
_700438 = 4.000000e+00f * _700437;
float _693535;
_693535 = *_693534;
float _700439;
_700439 = _700370 + _700438;
float _700441;
_700441 = _693535;
float _700442;
_700442 = 4.000000e+00f * _700441;
float _693542;
_693542 = *_693541;
float _700443;
_700443 = _700440 + _700442;
float _700444;
_700444 = _693542;
float _700445;
_700445 = 6.000000e+00f * _700444;
float _693548;
_693548 = *_693547;
float _700446;
_700446 = _700443 + _700445;
float _700447;
_700447 = _693548;
float _700448;
_700448 = 4.000000e+00f * _700447;
float _693554;
_693554 = *_693553;
float _700449;
_700449 = _700446 + _700448;
float _700450;
_700450 = _693554;
float _700451;
_700451 = _700449 + _700450;
float _693563;
_693563 = *_693562;
float _700452;
_700452 = _693563;
float _693570;
_693570 = *_693569;
float _700453;
_700453 = _693570;
float _700454;
_700454 = 4.000000e+00f * _700453;
float _693577;
_693577 = *_693576;
float _700455;
_700455 = _700452 + _700454;
float _700456;
_700456 = _693577;
float _700457;
_700457 = 6.000000e+00f * _700456;
float _693583;
_693583 = *_693582;
float _700458;
_700458 = _700455 + _700457;
float _700459;
_700459 = _693583;
float _700460;
_700460 = 4.000000e+00f * _700459;
float _693589;
_693589 = *_693588;
float _700461;
_700461 = _700458 + _700460;
float _700462;
_700462 = _693589;
float _700463;
_700463 = _700461 + _700462;
float _693598;
_693598 = *_693597;
float _700464;
_700464 = 4.000000e+00f * _700463;
float _700466;
_700466 = _693598;
float _700465;
_700465 = _700451 + _700464;
float _693605;
_693605 = *_693604;
float _700467;
_700467 = _693605;
float _700468;
_700468 = 4.000000e+00f * _700467;
float _693612;
_693612 = *_693611;
float _700469;
_700469 = _700466 + _700468;
float _700470;
_700470 = _693612;
float _700471;
_700471 = 6.000000e+00f * _700470;
float _693618;
_693618 = *_693617;
float _700472;
_700472 = _700469 + _700471;
float _700473;
_700473 = _693618;
float _700474;
_700474 = 4.000000e+00f * _700473;
float _693624;
_693624 = *_693623;
float _700475;
_700475 = _700472 + _700474;
float _700476;
_700476 = _693624;
float _700477;
_700477 = _700475 + _700476;
float _693633;
_693633 = *_693632;
float _700478;
_700478 = 6.000000e+00f * _700477;
float _700480;
_700480 = _693633;
float _700479;
_700479 = _700465 + _700478;
float _693640;
_693640 = *_693639;
float _700481;
_700481 = _693640;
float _700482;
_700482 = 4.000000e+00f * _700481;
float _693647;
_693647 = *_693646;
float _700483;
_700483 = _700480 + _700482;
float _700484;
_700484 = _693647;
float _700485;
_700485 = 6.000000e+00f * _700484;
float _693653;
_693653 = *_693652;
float _700486;
_700486 = _700483 + _700485;
float _700487;
_700487 = _693653;
float _700488;
_700488 = 4.000000e+00f * _700487;
float _693659;
_693659 = *_693658;
float _700489;
_700489 = _700486 + _700488;
float _700490;
_700490 = _693659;
float _700491;
_700491 = _700489 + _700490;
float _693668;
_693668 = *_693667;
float _700492;
_700492 = 4.000000e+00f * _700491;
float _700494;
_700494 = _693668;
float _700493;
_700493 = _700479 + _700492;
float _693675;
_693675 = *_693674;
float _700495;
_700495 = _693675;
float _700496;
_700496 = 4.000000e+00f * _700495;
float _693682;
_693682 = *_693681;
float _700497;
_700497 = _700494 + _700496;
float _700498;
_700498 = _693682;
float _700499;
_700499 = 6.000000e+00f * _700498;
float _693688;
_693688 = *_693687;
float _700500;
_700500 = _700497 + _700499;
float _700501;
_700501 = _693688;
float _700502;
_700502 = 4.000000e+00f * _700501;
float _693694;
_693694 = *_693693;
float _700503;
_700503 = _700500 + _700502;
float _700504;
_700504 = _693694;
float _700505;
_700505 = _700503 + _700504;
float _693704;
_693704 = *_693703;
float _700506;
_700506 = _700493 + _700505;
float _700509;
_700509 = _693704;
float _700507;
_700507 = 6.000000e+00f * _700506;
float _693711;
_693711 = *_693710;
float _700508;
_700508 = _700439 + _700507;
float _700510;
_700510 = _693711;
float _700511;
_700511 = 4.000000e+00f * _700510;
float _693718;
_693718 = *_693717;
float _700512;
_700512 = _700509 + _700511;
float _700513;
_700513 = _693718;
float _700514;
_700514 = 6.000000e+00f * _700513;
float _693724;
_693724 = *_693723;
float _700515;
_700515 = _700512 + _700514;
float _700516;
_700516 = _693724;
float _700517;
_700517 = 4.000000e+00f * _700516;
float _693730;
_693730 = *_693729;
float _700518;
_700518 = _700515 + _700517;
float _700519;
_700519 = _693730;
float _700520;
_700520 = _700518 + _700519;
float _693739;
_693739 = *_693738;
float _700521;
_700521 = _693739;
float _693746;
_693746 = *_693745;
float _700522;
_700522 = _693746;
float _700523;
_700523 = 4.000000e+00f * _700522;
float _693753;
_693753 = *_693752;
float _700524;
_700524 = _700521 + _700523;
float _700525;
_700525 = _693753;
float _700526;
_700526 = 6.000000e+00f * _700525;
float _693759;
_693759 = *_693758;
float _700527;
_700527 = _700524 + _700526;
float _700528;
_700528 = _693759;
float _700529;
_700529 = 4.000000e+00f * _700528;
float _693765;
_693765 = *_693764;
float _700530;
_700530 = _700527 + _700529;
float _700531;
_700531 = _693765;
float _700532;
_700532 = _700530 + _700531;
float _693774;
_693774 = *_693773;
float _700533;
_700533 = 4.000000e+00f * _700532;
float _700535;
_700535 = _693774;
float _700534;
_700534 = _700520 + _700533;
float _693781;
_693781 = *_693780;
float _700536;
_700536 = _693781;
float _700537;
_700537 = 4.000000e+00f * _700536;
float _693788;
_693788 = *_693787;
float _700538;
_700538 = _700535 + _700537;
float _700539;
_700539 = _693788;
float _700540;
_700540 = 6.000000e+00f * _700539;
float _693794;
_693794 = *_693793;
float _700541;
_700541 = _700538 + _700540;
float _700542;
_700542 = _693794;
float _700543;
_700543 = 4.000000e+00f * _700542;
float _693800;
_693800 = *_693799;
float _700544;
_700544 = _700541 + _700543;
float _700545;
_700545 = _693800;
float _700546;
_700546 = _700544 + _700545;
float _693809;
_693809 = *_693808;
float _700547;
_700547 = 6.000000e+00f * _700546;
float _700549;
_700549 = _693809;
float _700548;
_700548 = _700534 + _700547;
float _693816;
_693816 = *_693815;
float _700550;
_700550 = _693816;
float _700551;
_700551 = 4.000000e+00f * _700550;
float _693823;
_693823 = *_693822;
float _700552;
_700552 = _700549 + _700551;
float _700553;
_700553 = _693823;
float _700554;
_700554 = 6.000000e+00f * _700553;
float _693829;
_693829 = *_693828;
float _700555;
_700555 = _700552 + _700554;
float _700556;
_700556 = _693829;
float _700557;
_700557 = 4.000000e+00f * _700556;
float _693835;
_693835 = *_693834;
float _700558;
_700558 = _700555 + _700557;
float _700559;
_700559 = _693835;
float _700560;
_700560 = _700558 + _700559;
float _693844;
_693844 = *_693843;
float _700561;
_700561 = 4.000000e+00f * _700560;
float _700563;
_700563 = _693844;
float _700562;
_700562 = _700548 + _700561;
float _693851;
_693851 = *_693850;
float _700564;
_700564 = _693851;
float _700565;
_700565 = 4.000000e+00f * _700564;
float _693858;
_693858 = *_693857;
float _700566;
_700566 = _700563 + _700565;
float _700567;
_700567 = _693858;
float _700568;
_700568 = 6.000000e+00f * _700567;
float _693864;
_693864 = *_693863;
float _700569;
_700569 = _700566 + _700568;
float _700570;
_700570 = _693864;
float _700571;
_700571 = 4.000000e+00f * _700570;
float _693870;
_693870 = *_693869;
float _700572;
_700572 = _700569 + _700571;
float _700573;
_700573 = _693870;
float _700574;
_700574 = _700572 + _700573;
float _693880;
_693880 = *_693879;
float _700575;
_700575 = _700562 + _700574;
float _700578;
_700578 = _693880;
float _700576;
_700576 = 4.000000e+00f * _700575;
float _693887;
_693887 = *_693886;
float _700577;
_700577 = _700508 + _700576;
float _700579;
_700579 = _693887;
float _700580;
_700580 = 4.000000e+00f * _700579;
float _693894;
_693894 = *_693893;
float _700581;
_700581 = _700578 + _700580;
float _700582;
_700582 = _693894;
float _700583;
_700583 = 6.000000e+00f * _700582;
float _693900;
_693900 = *_693899;
float _700584;
_700584 = _700581 + _700583;
float _700585;
_700585 = _693900;
float _700586;
_700586 = 4.000000e+00f * _700585;
float _693906;
_693906 = *_693905;
float _700587;
_700587 = _700584 + _700586;
float _700588;
_700588 = _693906;
float _700589;
_700589 = _700587 + _700588;
float _693915;
_693915 = *_693914;
float _700590;
_700590 = _693915;
float _693922;
_693922 = *_693921;
float _700591;
_700591 = _693922;
float _700592;
_700592 = 4.000000e+00f * _700591;
float _693929;
_693929 = *_693928;
float _700593;
_700593 = _700590 + _700592;
float _700594;
_700594 = _693929;
float _700595;
_700595 = 6.000000e+00f * _700594;
float _693935;
_693935 = *_693934;
float _700596;
_700596 = _700593 + _700595;
float _700597;
_700597 = _693935;
float _700598;
_700598 = 4.000000e+00f * _700597;
float _693941;
_693941 = *_693940;
float _700599;
_700599 = _700596 + _700598;
float _700600;
_700600 = _693941;
float _700601;
_700601 = _700599 + _700600;
float _693950;
_693950 = *_693949;
float _700602;
_700602 = 4.000000e+00f * _700601;
float _700604;
_700604 = _693950;
float _700603;
_700603 = _700589 + _700602;
float _693957;
_693957 = *_693956;
float _700605;
_700605 = _693957;
float _700606;
_700606 = 4.000000e+00f * _700605;
float _693964;
_693964 = *_693963;
float _700607;
_700607 = _700604 + _700606;
float _700608;
_700608 = _693964;
float _700609;
_700609 = 6.000000e+00f * _700608;
float _693970;
_693970 = *_693969;
float _700610;
_700610 = _700607 + _700609;
float _700611;
_700611 = _693970;
float _700612;
_700612 = 4.000000e+00f * _700611;
float _693976;
_693976 = *_693975;
float _700613;
_700613 = _700610 + _700612;
float _700614;
_700614 = _693976;
float _700615;
_700615 = _700613 + _700614;
float _693985;
_693985 = *_693984;
float _700616;
_700616 = 6.000000e+00f * _700615;
float _700618;
_700618 = _693985;
float _700617;
_700617 = _700603 + _700616;
float _693992;
_693992 = *_693991;
float _700619;
_700619 = _693992;
float _700620;
_700620 = 4.000000e+00f * _700619;
float _693999;
_693999 = *_693998;
float _700621;
_700621 = _700618 + _700620;
float _700622;
_700622 = _693999;
float _700623;
_700623 = 6.000000e+00f * _700622;
float _694005;
_694005 = *_694004;
float _700624;
_700624 = _700621 + _700623;
float _700625;
_700625 = _694005;
float _700626;
_700626 = 4.000000e+00f * _700625;
float _694011;
_694011 = *_694010;
float _700627;
_700627 = _700624 + _700626;
float _700628;
_700628 = _694011;
float _700629;
_700629 = _700627 + _700628;
float _694020;
_694020 = *_694019;
float _700630;
_700630 = 4.000000e+00f * _700629;
float _700632;
_700632 = _694020;
float _700631;
_700631 = _700617 + _700630;
float _694027;
_694027 = *_694026;
float _700633;
_700633 = _694027;
float _700634;
_700634 = 4.000000e+00f * _700633;
float _694034;
_694034 = *_694033;
float _700635;
_700635 = _700632 + _700634;
float _700636;
_700636 = _694034;
float _700637;
_700637 = 6.000000e+00f * _700636;
float _694040;
_694040 = *_694039;
float _700638;
_700638 = _700635 + _700637;
float _700639;
_700639 = _694040;
float _700640;
_700640 = 4.000000e+00f * _700639;
float _694046;
_694046 = *_694045;
float _700641;
_700641 = _700638 + _700640;
float _700642;
_700642 = _694046;
float _700643;
_700643 = _700641 + _700642;
float _694056;
_694056 = *_694055;
float _700644;
_700644 = _700631 + _700643;
float _700649;
_700649 = _694056;
float _700645;
_700645 = _700577 + _700644;
float _694063;
_694063 = *_694062;
float _700646;
_700646 = xf_695819 * _700645;
float _700650;
_700650 = _694063;
float _700647;
_700647 = _700303 + _700646;
float _700651;
_700651 = 4.000000e+00f * _700650;
float _694070;
_694070 = *_694069;
float _700648;
_700648 = _695816 * _700647;
float _700652;
_700652 = _700649 + _700651;
float _700653;
_700653 = _694070;
float _700654;
_700654 = 6.000000e+00f * _700653;
float _694076;
_694076 = *_694075;
float _700655;
_700655 = _700652 + _700654;
float _700656;
_700656 = _694076;
float _700657;
_700657 = 4.000000e+00f * _700656;
float _694082;
_694082 = *_694081;
float _700658;
_700658 = _700655 + _700657;
float _700659;
_700659 = _694082;
float _700660;
_700660 = _700658 + _700659;
float _694091;
_694091 = *_694090;
float _700661;
_700661 = _694091;
float _694098;
_694098 = *_694097;
float _700662;
_700662 = _694098;
float _700663;
_700663 = 4.000000e+00f * _700662;
float _694105;
_694105 = *_694104;
float _700664;
_700664 = _700661 + _700663;
float _700665;
_700665 = _694105;
float _700666;
_700666 = 6.000000e+00f * _700665;
float _694111;
_694111 = *_694110;
float _700667;
_700667 = _700664 + _700666;
float _700668;
_700668 = _694111;
float _700669;
_700669 = 4.000000e+00f * _700668;
float _694117;
_694117 = *_694116;
float _700670;
_700670 = _700667 + _700669;
float _700671;
_700671 = _694117;
float _700672;
_700672 = _700670 + _700671;
float _694126;
_694126 = *_694125;
float _700673;
_700673 = 4.000000e+00f * _700672;
float _700675;
_700675 = _694126;
float _700674;
_700674 = _700660 + _700673;
float _694133;
_694133 = *_694132;
float _700676;
_700676 = _694133;
float _700677;
_700677 = 4.000000e+00f * _700676;
float _694140;
_694140 = *_694139;
float _700678;
_700678 = _700675 + _700677;
float _700679;
_700679 = _694140;
float _700680;
_700680 = 6.000000e+00f * _700679;
float _694146;
_694146 = *_694145;
float _700681;
_700681 = _700678 + _700680;
float _700682;
_700682 = _694146;
float _700683;
_700683 = 4.000000e+00f * _700682;
float _694152;
_694152 = *_694151;
float _700684;
_700684 = _700681 + _700683;
float _700685;
_700685 = _694152;
float _700686;
_700686 = _700684 + _700685;
float _694161;
_694161 = *_694160;
float _700687;
_700687 = 6.000000e+00f * _700686;
float _700689;
_700689 = _694161;
float _700688;
_700688 = _700674 + _700687;
float _694168;
_694168 = *_694167;
float _700690;
_700690 = _694168;
float _700691;
_700691 = 4.000000e+00f * _700690;
float _694175;
_694175 = *_694174;
float _700692;
_700692 = _700689 + _700691;
float _700693;
_700693 = _694175;
float _700694;
_700694 = 6.000000e+00f * _700693;
float _694181;
_694181 = *_694180;
float _700695;
_700695 = _700692 + _700694;
float _700696;
_700696 = _694181;
float _700697;
_700697 = 4.000000e+00f * _700696;
float _694187;
_694187 = *_694186;
float _700698;
_700698 = _700695 + _700697;
float _700699;
_700699 = _694187;
float _700700;
_700700 = _700698 + _700699;
float _694196;
_694196 = *_694195;
float _700701;
_700701 = 4.000000e+00f * _700700;
float _700703;
_700703 = _694196;
float _700702;
_700702 = _700688 + _700701;
float _694203;
_694203 = *_694202;
float _700704;
_700704 = _694203;
float _700705;
_700705 = 4.000000e+00f * _700704;
float _694210;
_694210 = *_694209;
float _700706;
_700706 = _700703 + _700705;
float _700707;
_700707 = _694210;
float _700708;
_700708 = 6.000000e+00f * _700707;
float _694216;
_694216 = *_694215;
float _700709;
_700709 = _700706 + _700708;
float _700710;
_700710 = _694216;
float _700711;
_700711 = 4.000000e+00f * _700710;
float _694222;
_694222 = *_694221;
float _700712;
_700712 = _700709 + _700711;
float _700713;
_700713 = _694222;
float _700714;
_700714 = _700712 + _700713;
float _694232;
_694232 = *_694231;
float _700715;
_700715 = _700702 + _700714;
float _700716;
_700716 = _694232;
float _694239;
_694239 = *_694238;
float _700717;
_700717 = _694239;
float _700718;
_700718 = 4.000000e+00f * _700717;
float _694246;
_694246 = *_694245;
float _700719;
_700719 = _700716 + _700718;
float _700720;
_700720 = _694246;
float _700721;
_700721 = 6.000000e+00f * _700720;
float _694252;
_694252 = *_694251;
float _700722;
_700722 = _700719 + _700721;
float _700723;
_700723 = _694252;
float _700724;
_700724 = 4.000000e+00f * _700723;
float _694258;
_694258 = *_694257;
float _700725;
_700725 = _700722 + _700724;
float _700726;
_700726 = _694258;
float _700727;
_700727 = _700725 + _700726;
float _694267;
_694267 = *_694266;
float _700728;
_700728 = _694267;
float _694274;
_694274 = *_694273;
float _700729;
_700729 = _694274;
float _700730;
_700730 = 4.000000e+00f * _700729;
float _694281;
_694281 = *_694280;
float _700731;
_700731 = _700728 + _700730;
float _700732;
_700732 = _694281;
float _700733;
_700733 = 6.000000e+00f * _700732;
float _694287;
_694287 = *_694286;
float _700734;
_700734 = _700731 + _700733;
float _700735;
_700735 = _694287;
float _700736;
_700736 = 4.000000e+00f * _700735;
float _694293;
_694293 = *_694292;
float _700737;
_700737 = _700734 + _700736;
float _700738;
_700738 = _694293;
float _700739;
_700739 = _700737 + _700738;
float _694302;
_694302 = *_694301;
float _700740;
_700740 = 4.000000e+00f * _700739;
float _700742;
_700742 = _694302;
float _700741;
_700741 = _700727 + _700740;
float _694309;
_694309 = *_694308;
float _700743;
_700743 = _694309;
float _700744;
_700744 = 4.000000e+00f * _700743;
float _694316;
_694316 = *_694315;
float _700745;
_700745 = _700742 + _700744;
float _700746;
_700746 = _694316;
float _700747;
_700747 = 6.000000e+00f * _700746;
float _694322;
_694322 = *_694321;
float _700748;
_700748 = _700745 + _700747;
float _700749;
_700749 = _694322;
float _700750;
_700750 = 4.000000e+00f * _700749;
float _694328;
_694328 = *_694327;
float _700751;
_700751 = _700748 + _700750;
float _700752;
_700752 = _694328;
float _700753;
_700753 = _700751 + _700752;
float _694337;
_694337 = *_694336;
float _700754;
_700754 = 6.000000e+00f * _700753;
float _700756;
_700756 = _694337;
float _700755;
_700755 = _700741 + _700754;
float _694344;
_694344 = *_694343;
float _700757;
_700757 = _694344;
float _700758;
_700758 = 4.000000e+00f * _700757;
float _694351;
_694351 = *_694350;
float _700759;
_700759 = _700756 + _700758;
float _700760;
_700760 = _694351;
float _700761;
_700761 = 6.000000e+00f * _700760;
float _694357;
_694357 = *_694356;
float _700762;
_700762 = _700759 + _700761;
float _700763;
_700763 = _694357;
float _700764;
_700764 = 4.000000e+00f * _700763;
float _694363;
_694363 = *_694362;
float _700765;
_700765 = _700762 + _700764;
float _700766;
_700766 = _694363;
float _700767;
_700767 = _700765 + _700766;
float _694372;
_694372 = *_694371;
float _700768;
_700768 = 4.000000e+00f * _700767;
float _700770;
_700770 = _694372;
float _700769;
_700769 = _700755 + _700768;
float _694379;
_694379 = *_694378;
float _700771;
_700771 = _694379;
float _700772;
_700772 = 4.000000e+00f * _700771;
float _694386;
_694386 = *_694385;
float _700773;
_700773 = _700770 + _700772;
float _700774;
_700774 = _694386;
float _700775;
_700775 = 6.000000e+00f * _700774;
float _694392;
_694392 = *_694391;
float _700776;
_700776 = _700773 + _700775;
float _700777;
_700777 = _694392;
float _700778;
_700778 = 4.000000e+00f * _700777;
float _694398;
_694398 = *_694397;
float _700779;
_700779 = _700776 + _700778;
float _700780;
_700780 = _694398;
float _700781;
_700781 = _700779 + _700780;
float _694408;
_694408 = *_694407;
float _700782;
_700782 = _700769 + _700781;
float _700785;
_700785 = _694408;
float _700783;
_700783 = 4.000000e+00f * _700782;
float _694415;
_694415 = *_694414;
float _700784;
_700784 = _700715 + _700783;
float _700786;
_700786 = _694415;
float _700787;
_700787 = 4.000000e+00f * _700786;
float _694422;
_694422 = *_694421;
float _700788;
_700788 = _700785 + _700787;
float _700789;
_700789 = _694422;
float _700790;
_700790 = 6.000000e+00f * _700789;
float _694428;
_694428 = *_694427;
float _700791;
_700791 = _700788 + _700790;
float _700792;
_700792 = _694428;
float _700793;
_700793 = 4.000000e+00f * _700792;
float _694434;
_694434 = *_694433;
float _700794;
_700794 = _700791 + _700793;
float _700795;
_700795 = _694434;
float _700796;
_700796 = _700794 + _700795;
float _694443;
_694443 = *_694442;
float _700797;
_700797 = _694443;
float _694450;
_694450 = *_694449;
float _700798;
_700798 = _694450;
float _700799;
_700799 = 4.000000e+00f * _700798;
float _694457;
_694457 = *_694456;
float _700800;
_700800 = _700797 + _700799;
float _700801;
_700801 = _694457;
float _700802;
_700802 = 6.000000e+00f * _700801;
float _694463;
_694463 = *_694462;
float _700803;
_700803 = _700800 + _700802;
float _700804;
_700804 = _694463;
float _700805;
_700805 = 4.000000e+00f * _700804;
float _694469;
_694469 = *_694468;
float _700806;
_700806 = _700803 + _700805;
float _700807;
_700807 = _694469;
float _700808;
_700808 = _700806 + _700807;
float _694478;
_694478 = *_694477;
float _700809;
_700809 = 4.000000e+00f * _700808;
float _700811;
_700811 = _694478;
float _700810;
_700810 = _700796 + _700809;
float _694485;
_694485 = *_694484;
float _700812;
_700812 = _694485;
float _700813;
_700813 = 4.000000e+00f * _700812;
float _694492;
_694492 = *_694491;
float _700814;
_700814 = _700811 + _700813;
float _700815;
_700815 = _694492;
float _700816;
_700816 = 6.000000e+00f * _700815;
float _694498;
_694498 = *_694497;
float _700817;
_700817 = _700814 + _700816;
float _700818;
_700818 = _694498;
float _700819;
_700819 = 4.000000e+00f * _700818;
float _694504;
_694504 = *_694503;
float _700820;
_700820 = _700817 + _700819;
float _700821;
_700821 = _694504;
float _700822;
_700822 = _700820 + _700821;
float _694513;
_694513 = *_694512;
float _700823;
_700823 = 6.000000e+00f * _700822;
float _700825;
_700825 = _694513;
float _700824;
_700824 = _700810 + _700823;
float _694520;
_694520 = *_694519;
float _700826;
_700826 = _694520;
float _700827;
_700827 = 4.000000e+00f * _700826;
float _694527;
_694527 = *_694526;
float _700828;
_700828 = _700825 + _700827;
float _700829;
_700829 = _694527;
float _700830;
_700830 = 6.000000e+00f * _700829;
float _694533;
_694533 = *_694532;
float _700831;
_700831 = _700828 + _700830;
float _700832;
_700832 = _694533;
float _700833;
_700833 = 4.000000e+00f * _700832;
float _694539;
_694539 = *_694538;
float _700834;
_700834 = _700831 + _700833;
float _700835;
_700835 = _694539;
float _700836;
_700836 = _700834 + _700835;
float _694548;
_694548 = *_694547;
float _700837;
_700837 = 4.000000e+00f * _700836;
float _700839;
_700839 = _694548;
float _700838;
_700838 = _700824 + _700837;
float _694555;
_694555 = *_694554;
float _700840;
_700840 = _694555;
float _700841;
_700841 = 4.000000e+00f * _700840;
float _694562;
_694562 = *_694561;
float _700842;
_700842 = _700839 + _700841;
float _700843;
_700843 = _694562;
float _700844;
_700844 = 6.000000e+00f * _700843;
float _694568;
_694568 = *_694567;
float _700845;
_700845 = _700842 + _700844;
float _700846;
_700846 = _694568;
float _700847;
_700847 = 4.000000e+00f * _700846;
float _694574;
_694574 = *_694573;
float _700848;
_700848 = _700845 + _700847;
float _700849;
_700849 = _694574;
float _700850;
_700850 = _700848 + _700849;
float _694584;
_694584 = *_694583;
float _700851;
_700851 = _700838 + _700850;
float _700854;
_700854 = _694584;
float _700852;
_700852 = 6.000000e+00f * _700851;
float _694591;
_694591 = *_694590;
float _700853;
_700853 = _700784 + _700852;
float _700855;
_700855 = _694591;
float _700856;
_700856 = 4.000000e+00f * _700855;
float _694598;
_694598 = *_694597;
float _700857;
_700857 = _700854 + _700856;
float _700858;
_700858 = _694598;
float _700859;
_700859 = 6.000000e+00f * _700858;
float _694604;
_694604 = *_694603;
float _700860;
_700860 = _700857 + _700859;
float _700861;
_700861 = _694604;
float _700862;
_700862 = 4.000000e+00f * _700861;
float _694610;
_694610 = *_694609;
float _700863;
_700863 = _700860 + _700862;
float _700864;
_700864 = _694610;
float _700865;
_700865 = _700863 + _700864;
float _694619;
_694619 = *_694618;
float _700866;
_700866 = _694619;
float _694626;
_694626 = *_694625;
float _700867;
_700867 = _694626;
float _700868;
_700868 = 4.000000e+00f * _700867;
float _694633;
_694633 = *_694632;
float _700869;
_700869 = _700866 + _700868;
float _700870;
_700870 = _694633;
float _700871;
_700871 = 6.000000e+00f * _700870;
float _694639;
_694639 = *_694638;
float _700872;
_700872 = _700869 + _700871;
float _700873;
_700873 = _694639;
float _700874;
_700874 = 4.000000e+00f * _700873;
float _694645;
_694645 = *_694644;
float _700875;
_700875 = _700872 + _700874;
float _700876;
_700876 = _694645;
float _700877;
_700877 = _700875 + _700876;
float _694654;
_694654 = *_694653;
float _700878;
_700878 = 4.000000e+00f * _700877;
float _700880;
_700880 = _694654;
float _700879;
_700879 = _700865 + _700878;
float _694661;
_694661 = *_694660;
float _700881;
_700881 = _694661;
float _700882;
_700882 = 4.000000e+00f * _700881;
float _694668;
_694668 = *_694667;
float _700883;
_700883 = _700880 + _700882;
float _700884;
_700884 = _694668;
float _700885;
_700885 = 6.000000e+00f * _700884;
float _694674;
_694674 = *_694673;
float _700886;
_700886 = _700883 + _700885;
float _700887;
_700887 = _694674;
float _700888;
_700888 = 4.000000e+00f * _700887;
float _694680;
_694680 = *_694679;
float _700889;
_700889 = _700886 + _700888;
float _700890;
_700890 = _694680;
float _700891;
_700891 = _700889 + _700890;
float _694689;
_694689 = *_694688;
float _700892;
_700892 = 6.000000e+00f * _700891;
float _700894;
_700894 = _694689;
float _700893;
_700893 = _700879 + _700892;
float _694696;
_694696 = *_694695;
float _700895;
_700895 = _694696;
float _700896;
_700896 = 4.000000e+00f * _700895;
float _694703;
_694703 = *_694702;
float _700897;
_700897 = _700894 + _700896;
float _700898;
_700898 = _694703;
float _700899;
_700899 = 6.000000e+00f * _700898;
float _694709;
_694709 = *_694708;
float _700900;
_700900 = _700897 + _700899;
float _700901;
_700901 = _694709;
float _700902;
_700902 = 4.000000e+00f * _700901;
float _694715;
_694715 = *_694714;
float _700903;
_700903 = _700900 + _700902;
float _700904;
_700904 = _694715;
float _700905;
_700905 = _700903 + _700904;
float _694724;
_694724 = *_694723;
float _700906;
_700906 = 4.000000e+00f * _700905;
float _700908;
_700908 = _694724;
float _700907;
_700907 = _700893 + _700906;
float _694731;
_694731 = *_694730;
float _700909;
_700909 = _694731;
float _700910;
_700910 = 4.000000e+00f * _700909;
float _694738;
_694738 = *_694737;
float _700911;
_700911 = _700908 + _700910;
float _700912;
_700912 = _694738;
float _700913;
_700913 = 6.000000e+00f * _700912;
float _694744;
_694744 = *_694743;
float _700914;
_700914 = _700911 + _700913;
float _700915;
_700915 = _694744;
float _700916;
_700916 = 4.000000e+00f * _700915;
float _694750;
_694750 = *_694749;
float _700917;
_700917 = _700914 + _700916;
float _700918;
_700918 = _694750;
float _700919;
_700919 = _700917 + _700918;
float _694760;
_694760 = *_694759;
float _700920;
_700920 = _700907 + _700919;
float _700923;
_700923 = _694760;
float _700921;
_700921 = 4.000000e+00f * _700920;
float _694767;
_694767 = *_694766;
float _700922;
_700922 = _700853 + _700921;
float _700924;
_700924 = _694767;
float _700925;
_700925 = 4.000000e+00f * _700924;
float _694774;
_694774 = *_694773;
float _700926;
_700926 = _700923 + _700925;
float _700927;
_700927 = _694774;
float _700928;
_700928 = 6.000000e+00f * _700927;
float _694780;
_694780 = *_694779;
float _700929;
_700929 = _700926 + _700928;
float _700930;
_700930 = _694780;
float _700931;
_700931 = 4.000000e+00f * _700930;
float _694786;
_694786 = *_694785;
float _700932;
_700932 = _700929 + _700931;
float _700933;
_700933 = _694786;
float _700934;
_700934 = _700932 + _700933;
float _694795;
_694795 = *_694794;
float _700935;
_700935 = _694795;
float _694802;
_694802 = *_694801;
float _700936;
_700936 = _694802;
float _700937;
_700937 = 4.000000e+00f * _700936;
float _694809;
_694809 = *_694808;
float _700938;
_700938 = _700935 + _700937;
float _700939;
_700939 = _694809;
float _700940;
_700940 = 6.000000e+00f * _700939;
float _694815;
_694815 = *_694814;
float _700941;
_700941 = _700938 + _700940;
float _700942;
_700942 = _694815;
float _700943;
_700943 = 4.000000e+00f * _700942;
float _694821;
_694821 = *_694820;
float _700944;
_700944 = _700941 + _700943;
float _700945;
_700945 = _694821;
float _700946;
_700946 = _700944 + _700945;
float _694830;
_694830 = *_694829;
float _700947;
_700947 = 4.000000e+00f * _700946;
float _700949;
_700949 = _694830;
float _700948;
_700948 = _700934 + _700947;
float _694837;
_694837 = *_694836;
float _700950;
_700950 = _694837;
float _700951;
_700951 = 4.000000e+00f * _700950;
float _694844;
_694844 = *_694843;
float _700952;
_700952 = _700949 + _700951;
float _700953;
_700953 = _694844;
float _700954;
_700954 = 6.000000e+00f * _700953;
float _694850;
_694850 = *_694849;
float _700955;
_700955 = _700952 + _700954;
float _700956;
_700956 = _694850;
float _700957;
_700957 = 4.000000e+00f * _700956;
float _694856;
_694856 = *_694855;
float _700958;
_700958 = _700955 + _700957;
float _700959;
_700959 = _694856;
float _700960;
_700960 = _700958 + _700959;
float _694865;
_694865 = *_694864;
float _700961;
_700961 = 6.000000e+00f * _700960;
float _700963;
_700963 = _694865;
float _700962;
_700962 = _700948 + _700961;
float _694872;
_694872 = *_694871;
float _700964;
_700964 = _694872;
float _700965;
_700965 = 4.000000e+00f * _700964;
float _694879;
_694879 = *_694878;
float _700966;
_700966 = _700963 + _700965;
float _700967;
_700967 = _694879;
float _700968;
_700968 = 6.000000e+00f * _700967;
float _694885;
_694885 = *_694884;
float _700969;
_700969 = _700966 + _700968;
float _700970;
_700970 = _694885;
float _700971;
_700971 = 4.000000e+00f * _700970;
float _694891;
_694891 = *_694890;
float _700972;
_700972 = _700969 + _700971;
float _700973;
_700973 = _694891;
float _700974;
_700974 = _700972 + _700973;
float _694900;
_694900 = *_694899;
float _700975;
_700975 = 4.000000e+00f * _700974;
float _700977;
_700977 = _694900;
float _700976;
_700976 = _700962 + _700975;
float _694907;
_694907 = *_694906;
float _700978;
_700978 = _694907;
float _700979;
_700979 = 4.000000e+00f * _700978;
float _694914;
_694914 = *_694913;
float _700980;
_700980 = _700977 + _700979;
float _700981;
_700981 = _694914;
float _700982;
_700982 = 6.000000e+00f * _700981;
float _694920;
_694920 = *_694919;
float _700983;
_700983 = _700980 + _700982;
float _700984;
_700984 = _694920;
float _700985;
_700985 = 4.000000e+00f * _700984;
float _694926;
_694926 = *_694925;
float _700986;
_700986 = _700983 + _700985;
float _700987;
_700987 = _694926;
float _700988;
_700988 = _700986 + _700987;
float _694936;
_694936 = *_694935;
float _700989;
_700989 = _700976 + _700988;
float _700992;
_700992 = _694936;
float _700990;
_700990 = _700922 + _700989;
float _694943;
_694943 = *_694942;
float _700991;
_700991 = _695820 * _700990;
float _700993;
_700993 = _694943;
float _700994;
_700994 = 4.000000e+00f * _700993;
float _694950;
_694950 = *_694949;
float _700995;
_700995 = _700992 + _700994;
float _700996;
_700996 = _694950;
float _700997;
_700997 = 6.000000e+00f * _700996;
float _694956;
_694956 = *_694955;
float _700998;
_700998 = _700995 + _700997;
float _700999;
_700999 = _694956;
float _701000;
_701000 = 4.000000e+00f * _700999;
float _694962;
_694962 = *_694961;
float _701001;
_701001 = _700998 + _701000;
float _701002;
_701002 = _694962;
float _701003;
_701003 = _701001 + _701002;
float _694971;
_694971 = *_694970;
float _701004;
_701004 = _694971;
float _694978;
_694978 = *_694977;
float _701005;
_701005 = _694978;
float _701006;
_701006 = 4.000000e+00f * _701005;
float _694985;
_694985 = *_694984;
float _701007;
_701007 = _701004 + _701006;
float _701008;
_701008 = _694985;
float _701009;
_701009 = 6.000000e+00f * _701008;
float _694991;
_694991 = *_694990;
float _701010;
_701010 = _701007 + _701009;
float _701011;
_701011 = _694991;
float _701012;
_701012 = 4.000000e+00f * _701011;
float _694997;
_694997 = *_694996;
float _701013;
_701013 = _701010 + _701012;
float _701014;
_701014 = _694997;
float _701015;
_701015 = _701013 + _701014;
float _695006;
_695006 = *_695005;
float _701016;
_701016 = 4.000000e+00f * _701015;
float _701018;
_701018 = _695006;
float _701017;
_701017 = _701003 + _701016;
float _695013;
_695013 = *_695012;
float _701019;
_701019 = _695013;
float _701020;
_701020 = 4.000000e+00f * _701019;
float _695020;
_695020 = *_695019;
float _701021;
_701021 = _701018 + _701020;
float _701022;
_701022 = _695020;
float _701023;
_701023 = 6.000000e+00f * _701022;
float _695026;
_695026 = *_695025;
float _701024;
_701024 = _701021 + _701023;
float _701025;
_701025 = _695026;
float _701026;
_701026 = 4.000000e+00f * _701025;
float _695032;
_695032 = *_695031;
float _701027;
_701027 = _701024 + _701026;
float _701028;
_701028 = _695032;
float _701029;
_701029 = _701027 + _701028;
float _695041;
_695041 = *_695040;
float _701030;
_701030 = 6.000000e+00f * _701029;
float _701032;
_701032 = _695041;
float _701031;
_701031 = _701017 + _701030;
float _695048;
_695048 = *_695047;
float _701033;
_701033 = _695048;
float _701034;
_701034 = 4.000000e+00f * _701033;
float _695055;
_695055 = *_695054;
float _701035;
_701035 = _701032 + _701034;
float _701036;
_701036 = _695055;
float _701037;
_701037 = 6.000000e+00f * _701036;
float _695061;
_695061 = *_695060;
float _701038;
_701038 = _701035 + _701037;
float _701039;
_701039 = _695061;
float _701040;
_701040 = 4.000000e+00f * _701039;
float _695067;
_695067 = *_695066;
float _701041;
_701041 = _701038 + _701040;
float _701042;
_701042 = _695067;
float _701043;
_701043 = _701041 + _701042;
float _695076;
_695076 = *_695075;
float _701044;
_701044 = 4.000000e+00f * _701043;
float _701046;
_701046 = _695076;
float _701045;
_701045 = _701031 + _701044;
float _695083;
_695083 = *_695082;
float _701047;
_701047 = _695083;
float _701048;
_701048 = 4.000000e+00f * _701047;
float _695090;
_695090 = *_695089;
float _701049;
_701049 = _701046 + _701048;
float _701050;
_701050 = _695090;
float _701051;
_701051 = 6.000000e+00f * _701050;
float _695096;
_695096 = *_695095;
float _701052;
_701052 = _701049 + _701051;
float _701053;
_701053 = _695096;
float _701054;
_701054 = 4.000000e+00f * _701053;
float _695102;
_695102 = *_695101;
float _701055;
_701055 = _701052 + _701054;
float _701056;
_701056 = _695102;
float _701057;
_701057 = _701055 + _701056;
float _695112;
_695112 = *_695111;
float _701058;
_701058 = _701045 + _701057;
float _701059;
_701059 = _695112;
float _695119;
_695119 = *_695118;
float _701060;
_701060 = _695119;
float _701061;
_701061 = 4.000000e+00f * _701060;
float _695126;
_695126 = *_695125;
float _701062;
_701062 = _701059 + _701061;
float _701063;
_701063 = _695126;
float _701064;
_701064 = 6.000000e+00f * _701063;
float _695132;
_695132 = *_695131;
float _701065;
_701065 = _701062 + _701064;
float _701066;
_701066 = _695132;
float _701067;
_701067 = 4.000000e+00f * _701066;
float _695138;
_695138 = *_695137;
float _701068;
_701068 = _701065 + _701067;
float _701069;
_701069 = _695138;
float _701070;
_701070 = _701068 + _701069;
float _695147;
_695147 = *_695146;
float _701071;
_701071 = _695147;
float _695154;
_695154 = *_695153;
float _701072;
_701072 = _695154;
float _701073;
_701073 = 4.000000e+00f * _701072;
float _695161;
_695161 = *_695160;
float _701074;
_701074 = _701071 + _701073;
float _701075;
_701075 = _695161;
float _701076;
_701076 = 6.000000e+00f * _701075;
float _695167;
_695167 = *_695166;
float _701077;
_701077 = _701074 + _701076;
float _701078;
_701078 = _695167;
float _701079;
_701079 = 4.000000e+00f * _701078;
float _695173;
_695173 = *_695172;
float _701080;
_701080 = _701077 + _701079;
float _701081;
_701081 = _695173;
float _701082;
_701082 = _701080 + _701081;
float _695182;
_695182 = *_695181;
float _701083;
_701083 = 4.000000e+00f * _701082;
float _701085;
_701085 = _695182;
float _701084;
_701084 = _701070 + _701083;
float _695189;
_695189 = *_695188;
float _701086;
_701086 = _695189;
float _701087;
_701087 = 4.000000e+00f * _701086;
float _695196;
_695196 = *_695195;
float _701088;
_701088 = _701085 + _701087;
float _701089;
_701089 = _695196;
float _701090;
_701090 = 6.000000e+00f * _701089;
float _695202;
_695202 = *_695201;
float _701091;
_701091 = _701088 + _701090;
float _701092;
_701092 = _695202;
float _701093;
_701093 = 4.000000e+00f * _701092;
float _695208;
_695208 = *_695207;
float _701094;
_701094 = _701091 + _701093;
float _701095;
_701095 = _695208;
float _701096;
_701096 = _701094 + _701095;
float _695217;
_695217 = *_695216;
float _701097;
_701097 = 6.000000e+00f * _701096;
float _701099;
_701099 = _695217;
float _701098;
_701098 = _701084 + _701097;
float _695224;
_695224 = *_695223;
float _701100;
_701100 = _695224;
float _701101;
_701101 = 4.000000e+00f * _701100;
float _695231;
_695231 = *_695230;
float _701102;
_701102 = _701099 + _701101;
float _701103;
_701103 = _695231;
float _701104;
_701104 = 6.000000e+00f * _701103;
float _695237;
_695237 = *_695236;
float _701105;
_701105 = _701102 + _701104;
float _701106;
_701106 = _695237;
float _701107;
_701107 = 4.000000e+00f * _701106;
float _695243;
_695243 = *_695242;
float _701108;
_701108 = _701105 + _701107;
float _701109;
_701109 = _695243;
float _701110;
_701110 = _701108 + _701109;
float _695252;
_695252 = *_695251;
float _701111;
_701111 = 4.000000e+00f * _701110;
float _701113;
_701113 = _695252;
float _701112;
_701112 = _701098 + _701111;
float _695259;
_695259 = *_695258;
float _701114;
_701114 = _695259;
float _701115;
_701115 = 4.000000e+00f * _701114;
float _695266;
_695266 = *_695265;
float _701116;
_701116 = _701113 + _701115;
float _701117;
_701117 = _695266;
float _701118;
_701118 = 6.000000e+00f * _701117;
float _695272;
_695272 = *_695271;
float _701119;
_701119 = _701116 + _701118;
float _701120;
_701120 = _695272;
float _701121;
_701121 = 4.000000e+00f * _701120;
float _695278;
_695278 = *_695277;
float _701122;
_701122 = _701119 + _701121;
float _701123;
_701123 = _695278;
float _701124;
_701124 = _701122 + _701123;
float _695288;
_695288 = *_695287;
float _701125;
_701125 = _701112 + _701124;
float _701128;
_701128 = _695288;
float _701126;
_701126 = 4.000000e+00f * _701125;
float _695295;
_695295 = *_695294;
float _701127;
_701127 = _701058 + _701126;
float _701129;
_701129 = _695295;
float _701130;
_701130 = 4.000000e+00f * _701129;
float _695302;
_695302 = *_695301;
float _701131;
_701131 = _701128 + _701130;
float _701132;
_701132 = _695302;
float _701133;
_701133 = 6.000000e+00f * _701132;
float _695308;
_695308 = *_695307;
float _701134;
_701134 = _701131 + _701133;
float _701135;
_701135 = _695308;
float _701136;
_701136 = 4.000000e+00f * _701135;
float _695314;
_695314 = *_695313;
float _701137;
_701137 = _701134 + _701136;
float _701138;
_701138 = _695314;
float _701139;
_701139 = _701137 + _701138;
float _695323;
_695323 = *_695322;
float _701140;
_701140 = _695323;
float _695330;
_695330 = *_695329;
float _701141;
_701141 = _695330;
float _701142;
_701142 = 4.000000e+00f * _701141;
float _695337;
_695337 = *_695336;
float _701143;
_701143 = _701140 + _701142;
float _701144;
_701144 = _695337;
float _701145;
_701145 = 6.000000e+00f * _701144;
float _695343;
_695343 = *_695342;
float _701146;
_701146 = _701143 + _701145;
float _701147;
_701147 = _695343;
float _701148;
_701148 = 4.000000e+00f * _701147;
float _695349;
_695349 = *_695348;
float _701149;
_701149 = _701146 + _701148;
float _701150;
_701150 = _695349;
float _701151;
_701151 = _701149 + _701150;
float _695358;
_695358 = *_695357;
float _701152;
_701152 = 4.000000e+00f * _701151;
float _701154;
_701154 = _695358;
float _701153;
_701153 = _701139 + _701152;
float _695365;
_695365 = *_695364;
float _701155;
_701155 = _695365;
float _701156;
_701156 = 4.000000e+00f * _701155;
float _695372;
_695372 = *_695371;
float _701157;
_701157 = _701154 + _701156;
float _701158;
_701158 = _695372;
float _701159;
_701159 = 6.000000e+00f * _701158;
float _695378;
_695378 = *_695377;
float _701160;
_701160 = _701157 + _701159;
float _701161;
_701161 = _695378;
float _701162;
_701162 = 4.000000e+00f * _701161;
float _695384;
_695384 = *_695383;
float _701163;
_701163 = _701160 + _701162;
float _701164;
_701164 = _695384;
float _701165;
_701165 = _701163 + _701164;
float _695393;
_695393 = *_695392;
float _701166;
_701166 = 6.000000e+00f * _701165;
float _701168;
_701168 = _695393;
float _701167;
_701167 = _701153 + _701166;
float _695400;
_695400 = *_695399;
float _701169;
_701169 = _695400;
float _701170;
_701170 = 4.000000e+00f * _701169;
float _695407;
_695407 = *_695406;
float _701171;
_701171 = _701168 + _701170;
float _701172;
_701172 = _695407;
float _701173;
_701173 = 6.000000e+00f * _701172;
float _695413;
_695413 = *_695412;
float _701174;
_701174 = _701171 + _701173;
float _701175;
_701175 = _695413;
float _701176;
_701176 = 4.000000e+00f * _701175;
float _695419;
_695419 = *_695418;
float _701177;
_701177 = _701174 + _701176;
float _701178;
_701178 = _695419;
float _701179;
_701179 = _701177 + _701178;
float _695428;
_695428 = *_695427;
float _701180;
_701180 = 4.000000e+00f * _701179;
float _701182;
_701182 = _695428;
float _701181;
_701181 = _701167 + _701180;
float _695435;
_695435 = *_695434;
float _701183;
_701183 = _695435;
float _701184;
_701184 = 4.000000e+00f * _701183;
float _695442;
_695442 = *_695441;
float _701185;
_701185 = _701182 + _701184;
float _701186;
_701186 = _695442;
float _701187;
_701187 = 6.000000e+00f * _701186;
float _695448;
_695448 = *_695447;
float _701188;
_701188 = _701185 + _701187;
float _701189;
_701189 = _695448;
float _701190;
_701190 = 4.000000e+00f * _701189;
float _695454;
_695454 = *_695453;
float _701191;
_701191 = _701188 + _701190;
float _701192;
_701192 = _695454;
float _701193;
_701193 = _701191 + _701192;
float _695464;
_695464 = *_695463;
float _701194;
_701194 = _701181 + _701193;
float _701197;
_701197 = _695464;
float _701195;
_701195 = 6.000000e+00f * _701194;
float _695471;
_695471 = *_695470;
float _701196;
_701196 = _701127 + _701195;
float _701198;
_701198 = _695471;
float _701199;
_701199 = 4.000000e+00f * _701198;
float _695478;
_695478 = *_695477;
float _701200;
_701200 = _701197 + _701199;
float _701201;
_701201 = _695478;
float _701202;
_701202 = 6.000000e+00f * _701201;
float _695484;
_695484 = *_695483;
float _701203;
_701203 = _701200 + _701202;
float _701204;
_701204 = _695484;
float _701205;
_701205 = 4.000000e+00f * _701204;
float _695490;
_695490 = *_695489;
float _701206;
_701206 = _701203 + _701205;
float _701207;
_701207 = _695490;
float _701208;
_701208 = _701206 + _701207;
float _695499;
_695499 = *_695498;
float _701209;
_701209 = _695499;
float _695506;
_695506 = *_695505;
float _701210;
_701210 = _695506;
float _701211;
_701211 = 4.000000e+00f * _701210;
float _695513;
_695513 = *_695512;
float _701212;
_701212 = _701209 + _701211;
float _701213;
_701213 = _695513;
float _701214;
_701214 = 6.000000e+00f * _701213;
float _695519;
_695519 = *_695518;
float _701215;
_701215 = _701212 + _701214;
float _701216;
_701216 = _695519;
float _701217;
_701217 = 4.000000e+00f * _701216;
float _695525;
_695525 = *_695524;
float _701218;
_701218 = _701215 + _701217;
float _701219;
_701219 = _695525;
float _701220;
_701220 = _701218 + _701219;
float _695534;
_695534 = *_695533;
float _701221;
_701221 = 4.000000e+00f * _701220;
float _701223;
_701223 = _695534;
float _701222;
_701222 = _701208 + _701221;
float _695541;
_695541 = *_695540;
float _701224;
_701224 = _695541;
float _701225;
_701225 = 4.000000e+00f * _701224;
float _695548;
_695548 = *_695547;
float _701226;
_701226 = _701223 + _701225;
float _701227;
_701227 = _695548;
float _701228;
_701228 = 6.000000e+00f * _701227;
float _695554;
_695554 = *_695553;
float _701229;
_701229 = _701226 + _701228;
float _701230;
_701230 = _695554;
float _701231;
_701231 = 4.000000e+00f * _701230;
float _695560;
_695560 = *_695559;
float _701232;
_701232 = _701229 + _701231;
float _701233;
_701233 = _695560;
float _701234;
_701234 = _701232 + _701233;
float _695569;
_695569 = *_695568;
float _701235;
_701235 = 6.000000e+00f * _701234;
float _701237;
_701237 = _695569;
float _701236;
_701236 = _701222 + _701235;
float _695576;
_695576 = *_695575;
float _701238;
_701238 = _695576;
float _701239;
_701239 = 4.000000e+00f * _701238;
float _695583;
_695583 = *_695582;
float _701240;
_701240 = _701237 + _701239;
float _701241;
_701241 = _695583;
float _701242;
_701242 = 6.000000e+00f * _701241;
float _695589;
_695589 = *_695588;
float _701243;
_701243 = _701240 + _701242;
float _701244;
_701244 = _695589;
float _701245;
_701245 = 4.000000e+00f * _701244;
float _695595;
_695595 = *_695594;
float _701246;
_701246 = _701243 + _701245;
float _701247;
_701247 = _695595;
float _701248;
_701248 = _701246 + _701247;
float _695604;
_695604 = *_695603;
float _701249;
_701249 = 4.000000e+00f * _701248;
float _701251;
_701251 = _695604;
float _701250;
_701250 = _701236 + _701249;
float _695611;
_695611 = *_695610;
float _701252;
_701252 = _695611;
float _701253;
_701253 = 4.000000e+00f * _701252;
float _695618;
_695618 = *_695617;
float _701254;
_701254 = _701251 + _701253;
float _701255;
_701255 = _695618;
float _701256;
_701256 = 6.000000e+00f * _701255;
float _695624;
_695624 = *_695623;
float _701257;
_701257 = _701254 + _701256;
float _701258;
_701258 = _695624;
float _701259;
_701259 = 4.000000e+00f * _701258;
float _695630;
_695630 = *_695629;
float _701260;
_701260 = _701257 + _701259;
float _701261;
_701261 = _695630;
float _701262;
_701262 = _701260 + _701261;
float _695640;
_695640 = *_695639;
float _701263;
_701263 = _701250 + _701262;
float _701266;
_701266 = _695640;
float _701264;
_701264 = 4.000000e+00f * _701263;
float _695647;
_695647 = *_695646;
float _701265;
_701265 = _701196 + _701264;
float _701267;
_701267 = _695647;
float _701268;
_701268 = 4.000000e+00f * _701267;
float _695654;
_695654 = *_695653;
float _701269;
_701269 = _701266 + _701268;
float _701270;
_701270 = _695654;
float _701271;
_701271 = 6.000000e+00f * _701270;
float _695660;
_695660 = *_695659;
float _701272;
_701272 = _701269 + _701271;
float _701273;
_701273 = _695660;
float _701274;
_701274 = 4.000000e+00f * _701273;
float _695666;
_695666 = *_695665;
float _701275;
_701275 = _701272 + _701274;
float _701276;
_701276 = _695666;
float _701277;
_701277 = _701275 + _701276;
float _695675;
_695675 = *_695674;
float _701278;
_701278 = _695675;
float _695682;
_695682 = *_695681;
float _701279;
_701279 = _695682;
float _701280;
_701280 = 4.000000e+00f * _701279;
float _695689;
_695689 = *_695688;
float _701281;
_701281 = _701278 + _701280;
float _701282;
_701282 = _695689;
float _701283;
_701283 = 6.000000e+00f * _701282;
float _695695;
_695695 = *_695694;
float _701284;
_701284 = _701281 + _701283;
float _701285;
_701285 = _695695;
float _701286;
_701286 = 4.000000e+00f * _701285;
float _695701;
_695701 = *_695700;
float _701287;
_701287 = _701284 + _701286;
float _701288;
_701288 = _695701;
float _701289;
_701289 = _701287 + _701288;
float _695710;
_695710 = *_695709;
float _701290;
_701290 = 4.000000e+00f * _701289;
float _701292;
_701292 = _695710;
float _701291;
_701291 = _701277 + _701290;
float _695717;
_695717 = *_695716;
float _701293;
_701293 = _695717;
float _701294;
_701294 = 4.000000e+00f * _701293;
float _695724;
_695724 = *_695723;
float _701295;
_701295 = _701292 + _701294;
float _701296;
_701296 = _695724;
float _701297;
_701297 = 6.000000e+00f * _701296;
float _695730;
_695730 = *_695729;
float _701298;
_701298 = _701295 + _701297;
float _701299;
_701299 = _695730;
float _701300;
_701300 = 4.000000e+00f * _701299;
float _695736;
_695736 = *_695735;
float _701301;
_701301 = _701298 + _701300;
float _701302;
_701302 = _695736;
float _701303;
_701303 = _701301 + _701302;
float _695745;
_695745 = *_695744;
float _701304;
_701304 = 6.000000e+00f * _701303;
float _701306;
_701306 = _695745;
float _701305;
_701305 = _701291 + _701304;
float _695752;
_695752 = *_695751;
float _701307;
_701307 = _695752;
float _695759;
_695759 = *_695758;
float _701308;
_701308 = 4.000000e+00f * _701307;
float _701310;
_701310 = _695759;
float _701309;
_701309 = _701306 + _701308;
float _695765;
_695765 = *_695764;
float _701311;
_701311 = 6.000000e+00f * _701310;
float _701312;
_701312 = _701309 + _701311;
float _701313;
_701313 = _695765;
float _695771;
_695771 = *_695770;
float _701314;
_701314 = 4.000000e+00f * _701313;
float _701316;
_701316 = _695771;
float _701315;
_701315 = _701312 + _701314;
float _695780;
_695780 = *_695779;
float _701317;
_701317 = _701315 + _701316;
float _701320;
_701320 = _695780;
float _701318;
_701318 = 4.000000e+00f * _701317;
float _695787;
_695787 = *_695786;
float _701319;
_701319 = _701305 + _701318;
float _701321;
_701321 = _695787;
float _695794;
_695794 = *_695793;
float _701322;
_701322 = 4.000000e+00f * _701321;
float _701324;
_701324 = _695794;
float _701323;
_701323 = _701320 + _701322;
float _695800;
_695800 = *_695799;
float _701325;
_701325 = 6.000000e+00f * _701324;
float _701326;
_701326 = _701323 + _701325;
float _701327;
_701327 = _695800;
float _695806;
_695806 = *_695805;
float _701328;
_701328 = 4.000000e+00f * _701327;
float _701330;
_701330 = _695806;
float _701329;
_701329 = _701326 + _701328;
float _701331;
_701331 = _701329 + _701330;
float _701332;
_701332 = _701319 + _701331;
float _701333;
_701333 = _701265 + _701332;
float _701334;
_701334 = xf_695819 * _701333;
float _701335;
_701335 = _700991 + _701334;
float _701336;
_701336 = yf_695815 * _701335;
float _701337;
_701337 = _700648 + _701336;
float _701338;
_701338 = zf_698581 * _701337;
float _701339;
_701339 = _699960 + _701338;
float _701340;
_701340 = _698579 / _701339;
*_681214 = _701340;
return ;
}
__global__ __launch_bounds__ (32 * 4 * 1) void lambda_452720(int _452723_703776, float* _452724_703777, int _452725_703778, float* _452726_703779) {
int threadIdx_x_703782;
int pthreadIdx_x_703782;
int blockDim_x_703785;
int pblockDim_x_703785;
int blockIdx_x_703788;
int pblockIdx_x_703788;
int _703791;
int p_703791;
int _703794;
int p_703794;
int _703797;
int p_703797;
int _703800;
int p_703800;
int lower_703803;
int plower_703803;
int upper_703804;
int pupper_703804;
int step_703805;
int pstep_703805;
int lower_703810;
int plower_703810;
int upper_703811;
int pupper_703811;
int step_703812;
int pstep_703812;
int converge_703885;
int pconverge_703885;
int converge_703823;
int pconverge_703823;
int converge_703878;
int pconverge_703878;
int converge_703832;
int pconverge_703832;
float converge_703872;
float pconverge_703872;
float converge_703841;
float pconverge_703841;
threadIdx_x_703782 = threadIdx_x();
pthreadIdx_x_703782 = threadIdx_x_703782;
l703780: ;
threadIdx_x_703782 = pthreadIdx_x_703782;
blockDim_x_703785 = blockDim_x();
pblockDim_x_703785 = blockDim_x_703785;
l703783: ;
blockDim_x_703785 = pblockDim_x_703785;
blockIdx_x_703788 = blockIdx_x();
pblockIdx_x_703788 = blockIdx_x_703788;
l703786: ;
blockIdx_x_703788 = pblockIdx_x_703788;
_703791 = threadIdx_y();
p_703791 = _703791;
l703789: ;
_703791 = p_703791;
_703794 = blockDim_y();
p_703794 = _703794;
l703792: ;
_703794 = p_703794;
_703797 = blockIdx_y();
p_703797 = _703797;
l703795: ;
_703797 = p_703797;
_703800 = blockDim_y();
p_703800 = _703800;
l703798: ;
_703800 = p_703800;
int _703815;
_703815 = blockDim_x_703785 * blockIdx_x_703788;
int _703879;
_703879 = _452725_703778 - 1;
int gwidth_703843;
gwidth_703843 = _452723_703776 / 8;
int _703886;
_703886 = _452723_703776 - 1;
int _703816;
_703816 = threadIdx_x_703782 + _703815;
int _703824;
_703824 = _703794 * _703797;
int _703817;
_703817 = 8 * _703816;
int gid_y_703825;
gid_y_703825 = _703791 + _703824;
int _703826;
_703826 = 8 * gid_y_703825;
int _703844;
_703844 = gid_y_703825 * gwidth_703843;
int _703845;
_703845 = _703844 + _703816;
int _703846;
_703846 = 14 * _703845;
plower_703803 = 0;
pupper_703804 = 9;
pstep_703805 = 1;
goto l703801;
l703801: ;
lower_703803 = plower_703803;
upper_703804 = pupper_703804;
step_703805 = pstep_703805;
bool _703806;
_703806 = lower_703803 < upper_703804;
if (_703806) goto l703807; else goto l703891;
l703891: ;
return ;
l703807: ;
int _703827;
_703827 = _703826 + lower_703803;
int _703828;
_703828 = _703827 - 4;
bool _703829;
_703829 = _703828 < 0;
bool _703875;
_703875 = _452725_703778 <= _703828;
plower_703810 = 0;
pupper_703811 = 9;
pstep_703812 = 1;
goto l703808;
l703808: ;
lower_703810 = plower_703810;
upper_703811 = pupper_703811;
step_703812 = pstep_703812;
bool _703813;
_703813 = lower_703810 < upper_703811;
if (_703813) goto l703814; else goto l703888;
l703888: ;
int _703889;
_703889 = lower_703803 + step_703805;
plower_703803 = _703889;
pupper_703804 = upper_703804;
pstep_703805 = step_703805;
goto l703801;
l703814: ;
int _703818;
_703818 = _703817 + lower_703810;
int _703819;
_703819 = _703818 - 4;
bool _703820;
_703820 = _703819 < 0;
if (_703820) goto l703821; else goto l703881;
l703881: ;
bool _703882;
_703882 = _452723_703776 <= _703819;
if (_703882) goto l703883; else goto l703887;
l703887: ;
pconverge_703885 = _703819;
goto l703884;
l703883: ;
pconverge_703885 = _703886;
goto l703884;
l703884: ;
converge_703885 = pconverge_703885;
pconverge_703823 = converge_703885;
goto l703822;
l703821: ;
pconverge_703823 = 0;
goto l703822;
l703822: ;
converge_703823 = pconverge_703823;
if (_703829) goto l703830; else goto l703874;
l703874: ;
if (_703875) goto l703876; else goto l703880;
l703880: ;
pconverge_703878 = _703828;
goto l703877;
l703876: ;
pconverge_703878 = _703879;
goto l703877;
l703877: ;
converge_703878 = pconverge_703878;
pconverge_703832 = converge_703878;
goto l703831;
l703830: ;
pconverge_703832 = 0;
goto l703831;
l703831: ;
converge_703832 = pconverge_703832;
int _703833;
_703833 = converge_703832 * _452723_703776;
int _703834;
_703834 = _703833 + converge_703823;
float* _703835;
_703835 = _452724_703777 + _703834;
float _703836;
_703836 = *_703835;
float _703837;
_703837 = _703836;
bool _703838;
_703838 = _703837 < 0.000000e+00f;
if (_703838) goto l703839; else goto l703868;
l703868: ;
bool _703869;
_703869 = 1.000000e+00f <= _703837;
if (_703869) goto l703870; else goto l703873;
l703873: ;
pconverge_703872 = _703837;
goto l703871;
l703870: ;
pconverge_703872 = 1.000000e+00f;
goto l703871;
l703871: ;
converge_703872 = pconverge_703872;
pconverge_703841 = converge_703872;
goto l703840;
l703839: ;
pconverge_703841 = 0.000000e+00f;
goto l703840;
l703840: ;
converge_703841 = pconverge_703841;
float _703848;
_703848 = 1.000000e+01f * converge_703841;
int _703867;
_703867 = lower_703810 + step_703812;
float _703849;
_703849 = 5.000000e-01f + _703848;
int zi_703850;
zi_703850 = (int)_703849;
int _703851;
_703851 = _703846 + zi_703850;
int _703852;
_703852 = 2 + _703851;
int _703853;
_703853 = 2 * _703852;
int _703860;
_703860 = 1 + _703853;
float* _703854;
_703854 = _452726_703779 + _703853;
float* _703861;
_703861 = _452726_703779 + _703860;
float _703855;
_703855 = *_703854;
float _703857;
_703857 = _703855;
float _703858;
_703858 = _703857 + converge_703841;
*_703854 = _703858;
float _703862;
_703862 = *_703861;
float _703864;
_703864 = _703862;
float _703865;
_703865 = 1.000000e+00f + _703864;
*_703861 = _703865;
plower_703810 = _703867;
pupper_703811 = upper_703811;
pstep_703812 = step_703812;
goto l703808;
}
__global__ __launch_bounds__ (32 * 4 * 1) void lambda_452341(int _452344_703895, float* _452345_703896) {
int threadIdx_x_703899;
int pthreadIdx_x_703899;
int blockDim_x_703902;
int pblockDim_x_703902;
int blockIdx_x_703905;
int pblockIdx_x_703905;
int _703908;
int p_703908;
int _703911;
int p_703911;
int _703914;
int p_703914;
int _703917;
int p_703917;
int lower_703920;
int plower_703920;
int upper_703921;
int pupper_703921;
int step_703922;
int pstep_703922;
threadIdx_x_703899 = threadIdx_x();
pthreadIdx_x_703899 = threadIdx_x_703899;
l703897: ;
threadIdx_x_703899 = pthreadIdx_x_703899;
blockDim_x_703902 = blockDim_x();
pblockDim_x_703902 = blockDim_x_703902;
l703900: ;
blockDim_x_703902 = pblockDim_x_703902;
blockIdx_x_703905 = blockIdx_x();
pblockIdx_x_703905 = blockIdx_x_703905;
l703903: ;
blockIdx_x_703905 = pblockIdx_x_703905;
_703908 = threadIdx_y();
p_703908 = _703908;
l703906: ;
_703908 = p_703908;
_703911 = blockDim_y();
p_703911 = _703911;
l703909: ;
_703911 = p_703911;
_703914 = blockIdx_y();
p_703914 = _703914;
l703912: ;
_703914 = p_703914;
_703917 = blockDim_y();
p_703917 = _703917;
l703915: ;
_703917 = p_703917;
int _703929;
_703929 = blockDim_x_703902 * blockIdx_x_703905;
int gwidth_703927;
gwidth_703927 = _452344_703895 / 8;
int _703925;
_703925 = _703911 * _703914;
int gid_y_703926;
gid_y_703926 = _703908 + _703925;
int _703930;
_703930 = threadIdx_x_703899 + _703929;
int _703928;
_703928 = gid_y_703926 * gwidth_703927;
int _703931;
_703931 = _703928 + _703930;
int _703932;
_703932 = 14 * _703931;
plower_703920 = -2;
pupper_703921 = 12;
pstep_703922 = 1;
goto l703918;
l703918: ;
lower_703920 = plower_703920;
upper_703921 = pupper_703921;
step_703922 = pstep_703922;
bool _703923;
_703923 = lower_703920 < upper_703921;
if (_703923) goto l703924; else goto l703942;
l703942: ;
return ;
l703924: ;
int _703941;
_703941 = lower_703920 + step_703922;
int _703933;
_703933 = _703932 + lower_703920;
int _703934;
_703934 = 2 + _703933;
int _703935;
_703935 = 2 * _703934;
float* _703936;
_703936 = _452345_703896 + _703935;
int _703938;
_703938 = 1 + _703935;
*_703936 = 0.000000e+00f;
float* _703939;
_703939 = _452345_703896 + _703938;
*_703939 = 0.000000e+00f;
plower_703920 = _703941;
pupper_703921 = upper_703921;
pstep_703922 = step_703922;
goto l703918;
}
} |
10,239 | /*
* This program measures execution times for
* cuFFT convolution for array sizes of 2^N
* between MIN_SIZE and MAX_SIZE and saves the
* data to FILENAME in a format that can be
* easily read using NumPy. During execution,
* progress is printed to standard output, along
* with a measurement of the maximum error to
* ensure the computation is being performed
* correctly.
*
* compile using nvcc and link cuFFT with
* -lcufft
*/
#include <cufft.h>
#include <math.h>
#include <stdio.h>
#include <time.h>
#define FILENAME "gpu_convolution_performance_results.txt"
#define TRIALS 10
#define MIN_SIZE 1024 // 2^10
#define MAX_SIZE 268435456 // 2^28
#define BATCH 1 // batches in CUFFT plan
#define BLOCK_SIZE 128 // number of threads in a block
double execution_time(int array_size, int trial);
void convolve(cufftComplex *input, cufftComplex *filter, int size,
cufftHandle *plan);
__global__ void complex_mult_inplace(cufftComplex *z1, cufftComplex *z2, int size);
float error(cufftComplex z, cufftComplex z0);
int main(void)
{
FILE *fp;
fp = fopen(FILENAME, "w");
fprintf(fp, "## First column is array size, rest are times in milliseconds\n");
for (int size = MIN_SIZE; size <= MAX_SIZE; size = size * 2)
{
fprintf(fp, "%9d", size); // begin line with array size
for (int trial = 0; trial < TRIALS; ++trial) // perform trials
fprintf(fp, " %f", execution_time(size, trial));
fprintf(fp, "\n"); // end line
}
fclose(fp);
return 0;
}
double execution_time(int array_size, int trial)
{
/*
this function measures execution time and checks correctness
of a function for performing FFT convolution using CUFFT.
the filter used for convolution has an initial element of
1.0 + 0.0i followed by all zeros. this choice was made so that
correctness could be checked by comparing the output array to
a copy of the input array.
*/
// announce start of trial set
if (trial == 0)
printf("%d array elements", array_size);
// allocate host arrays
cufftComplex *input, *filter, *comparison;
input = (cufftComplex *)malloc(array_size * sizeof(cufftComplex));
filter = (cufftComplex *)malloc(array_size * sizeof(cufftComplex));
comparison = (cufftComplex *)malloc(array_size * sizeof(cufftComplex));
// initialize host arrays
for (int i = 0; i < array_size; ++i)
{
// input and comparison initialized with same values
input[i].x = comparison[i].x = (float)i;
input[i].y = comparison[i].y = 0.0f;
// filter initialized with all zeros
filter[i].x = filter[i].y = 0.0f;
}
// initialize first element as 1.0 + 0.0i
// (divide by array_size for initialization)
filter[0].x = 1.0f / (float)array_size;
// allocate device arrays
cufftComplex *dev_input, *dev_filter;
cudaMalloc((void **)&dev_input, array_size * sizeof(cufftComplex));
cudaMalloc((void **)&dev_filter, array_size * sizeof(cufftComplex));
// create cufft plan
cufftHandle plan;
cufftPlan1d(&plan, array_size, CUFFT_C2C, BATCH);
// copy data from host arrays to device arrays
cudaMemcpy(dev_input, input, array_size * sizeof(cufftComplex), cudaMemcpyHostToDevice);
cudaMemcpy(dev_filter, filter, array_size * sizeof(cufftComplex), cudaMemcpyHostToDevice);
// measure execution time of convolution
cudaEvent_t start, end;
cudaEventCreate(&start);
cudaEventCreate(&end);
cudaEventRecord(start);
convolve(dev_input, dev_filter, array_size, &plan);
cudaEventRecord(end);
cudaEventSynchronize(end);
float milliseconds = 0.0f;
cudaEventElapsedTime(&milliseconds, start, end);
// copy data from device input array to host input array
cudaMemcpy(input, dev_input, array_size * sizeof(cufftComplex), cudaMemcpyDeviceToHost);
// check max error and print results
float max_error = 0.0f, current_error = 0.0f;
for (int i = 0; i < array_size; ++i)
{
current_error = error(input[i], comparison[i]);
if (current_error > max_error)
max_error = current_error;
}
printf(" max error: %f;", max_error);
if (trial == TRIALS - 1)
printf("\n");
// clean up
cufftDestroy(plan);
cudaFree(dev_input);
cudaFree(dev_filter);
free(input);
free(filter);
free(comparison);
return milliseconds;
}
void convolve(cufftComplex *input, cufftComplex *filter, int size,
cufftHandle *plan)
{
// forward Fourier transform input and filter
cufftExecC2C(*plan, input, input, CUFFT_FORWARD);
cufftExecC2C(*plan, filter, filter, CUFFT_FORWARD);
//cudaDeviceSynchronize();
// multiply transformed arrays element-wise
int grid_size = (size + BLOCK_SIZE - 1) / BLOCK_SIZE;
complex_mult_inplace<<<grid_size, BLOCK_SIZE>>>(input, filter, size);
// inverse Fourier transform on product array
cufftExecC2C(*plan, input, input, CUFFT_INVERSE);
}
__global__ void complex_mult_inplace(cufftComplex *z1, cufftComplex *z2, int size)
{
int tid = threadIdx.x + blockIdx.x * blockDim.x;
if (tid < size)
{
float tx, ty, x1, y1, x2, y2;
x1 = z1[tid].x;
y1 = z1[tid].y;
x2 = z2[tid].x;
y2 = z2[tid].y;
tx = x1 * x2 - y1 * y2;
ty = x1 * y2 + y1 * x2;
z1[tid].x = tx;
z1[tid].y = ty;
}
}
float error(cufftComplex z, cufftComplex z0)
{
float dx, dy;
dx = z.x - z0.x;
dy = z.y - z0.y;
return sqrtf(dx * dx + dy * dy);
}
|
10,240 | #include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cmath>
#include <cuda_runtime_api.h>
#define SQ(x) ((x) * (x))
static const float A = -4.0, B = 4.0; // limites de integración
static const int N = 1 << 22; // número de intervalos = 2^22
static const float H = (B - A) / N; // tamaño del intervalo de integración
static const float PI(M_PI); // π con precision simple
float h(float x) {
return .5f + 1.5f / (1.0f + 50.0f * SQ(x));
}
float f(float x) {
int i;
float sum = 0.0f, x0;
for (i = 0; i < 10; ++i)
x0 = -3.3f + i * 0.7f;
sum += h(x - x0);
return sum/10.0f;
}
float g(float x) {
float c = cosf(2.0f * PI * f(x) * x);
return expf(-x/16.0f) * SQ(c);
}
__global__ void
integrate_blocks(float subtotals[]) {
}
int main(int argc, char *argv[]) {
// El programa recibe como parámetro el número de hebras por bloque.
// Recuerden que este número debe ser múltiplo de 32 (tamaño del warp)
// y puede ser a lo más 512 (limitación del hardware).
if (argc < 2) {
std::cerr << "Usage: " << argv[0] << " threads_per_block" << std::endl;
std::exit(1);
}
int block_size = std::atoi(argv[1]);
// Al usar N subintervalos, hay que evaluar la función en 2N + 1 puntos.
// Para paralelizar, mejor evaluar 2N puntos y sumar el último al final.
// Por lo tanto, necesitamos 2N hebras.
int nr_blocks = 2 * N / block_size;
// Reservar arreglos en RAM y en la GPU para guardar los resultados.
float *subtotals_h, *subtotals_d;
subtotals_h = new float[nr_blocks];
cudaMalloc((void **) &subtotals_d, sizeof(float) * nr_blocks);
integrate_blocks<<<nr_blocks, block_size>>>(subtotals_d);
// En la parte (a) de la tarea,
// la reducción global la hacemos en la CPU.
cudaMemcpy(subtotals_h, subtotals_d,
sizeof(float) * nr_blocks, cudaMemcpyDeviceToHost);
float sum = 0.0;
# pragma omp parallel for reduction(+: sum)
for (int b = 0; b < nr_blocks; ++b) {
sum += subtotals_h[b];
}
std::cout << sum << std::endl;
cudaFree(subtotals_d);
std::free(subtotals_h);
}
|
10,241 | #include "includes.h"
__global__ void initializeToValue_kernel(unsigned int *data, unsigned int value, int width, int height) {
const int x = blockIdx.x * blockDim.x + threadIdx.x;
const int y = blockIdx.y * blockDim.y + threadIdx.y;
if (x < width && y < height) {
data[y * width + x] = value;
}
} |
10,242 | #include <iostream>
#define N 640000
#define TPB 32
__host__
float scale(int i, int n)
{
return float(i) / ((float)(n-1));
}
__device__
float distance(float x1, float x2)
{
return sqrt((x2 - x1)*(x2 - x1));
}
__global__
void distanceKernel(float *d_out, float *d_in, float ref)
{
const int i = blockIdx.x*blockDim.x+threadIdx.x;
float x=d_in[i];
d_out[i]=distance(x,ref);
//printf("blockIdx = %2d, threadId = %2d, i = %2d: dist from %f to %f is %f.\n",
// blockIdx.x, threadIdx.x, i, x,ref,d_out[i]);
}
int main()
{
float *d_in = 0;
float *d_out = 0;
const float ref = 0.5;
cudaMallocManaged(&d_in, N*sizeof(float));
cudaMallocManaged(&d_out, N*sizeof(float));
for(int i=0; i < N;i++)
d_in[i]=scale(i,N);
distanceKernel<<<N/TPB, TPB>>>(d_out, d_in, ref);
cudaDeviceSynchronize();
cudaFree(d_in);
cudaFree(d_out);
return 0;
}
|
10,243 | #include "includes.h"
__global__ void convertPointCloudToDepthImage_kernel( unsigned int *depth_image, const float4 *point_cloud, int n_cols, int n_rows, int n_points, float nodal_point_x, float nodal_point_y, float focal_length_x, float focal_length_y, const float *T, const float *R) {
const int ind = blockIdx.x * blockDim.x + threadIdx.x;
if (ind < n_points) {
// fetch point
float4 point = point_cloud[ind];
// transform to camera frame
float x = R[0] * point.x + R[1] * point.y + R[2] * point.z + T[0];
float y = R[3] * point.x + R[4] * point.y + R[5] * point.z + T[1];
float z = R[6] * point.x + R[7] * point.y + R[8] * point.z + T[2];
float inv_z = 1.0f / z;
// project in image
int x_pix = __float2int_rn(focal_length_x * x * inv_z + nodal_point_x);
int y_pix = __float2int_rn(focal_length_y * y * inv_z + nodal_point_y);
// check if inside image
bool valid =
((x_pix >= 0) && (x_pix < n_cols) && (y_pix >= 0) && (y_pix < n_rows));
if (valid) {
int ind_out = y_pix * n_cols + x_pix;
// depth_image[ind_out] = (unsigned int)(point.z * 1000.0f);
atomicMin(depth_image + ind_out, (unsigned int)(point.z * 1000.0f));
}
}
} |
10,244 | #include "includes.h"
__global__ void hillisSteeleScanDevice(int *d_predicateArray , int d_numberOfElements ,int *d_tmpArray,int d_offset)
{
int index = blockIdx.x * blockDim.x + threadIdx.x;
if(index < d_numberOfElements)
{
d_tmpArray[index] = d_predicateArray[index];
if(index - d_offset >= 0)
{
d_tmpArray[index] = d_predicateArray[index] + d_predicateArray[index-d_offset];
}
}
} |
10,245 | #include <cuda.h>
#include <math.h>
#include <stdio.h>
#define NUM_THREADS 512
__global__ void cuda_svm_level_init(double *alpha_gm, int *train_cases_gm, double *kernel_val_mat,
double *opt_cond, double gamma, int num_train_cases, int NUM_FEATURES, int level);
__device__ double kernel_eval(int *arr1, int *arr2, int arr_len, int offset, double gamma);
void bias_bound_index(double *alpha, double *opt_cond, int *train_cases, int num_train_cases, int NUM_FEATURES,
double C, double *bias_low, double *bias_high, int *bias_low_indx, int *bias_high_indx);
__global__ void opt_cond_itr(int num_train_cases, double *opt_cond, double alpha_high, double alpha_high_prev,
int high_label, int high_indx, double alpha_low, double alpha_low_prev, int low_label,
int low_indx, double *kernel_val_mat);
__global__ void cuda_svm_test(double bias, int num_SVs, double *alpha_gm, int *SVs_gm, int *prediction,
int NUM_FEATURES, int *test_cases_gm, int num_test_cases, double gamma);
extern "C" void svm_train(double **alpha, double *bias, int **train_cases, int num_train_cases, int NUM_FEATURES,
double C, double gamma, double **kernel_val_mat, int max_itr, double tol, int level, int rank){
int i, j;
double bias_low, bias_high, eta;
int bias_low_indx, bias_high_indx;
double alpha_high_prev, alpha_low_prev;
//double kernel_val;
double *alpha_gm;
cudaMalloc( (void **) &alpha_gm, num_train_cases * sizeof(double) );
cudaMemcpy( alpha_gm, &alpha[0][1], num_train_cases*sizeof(double), cudaMemcpyHostToDevice );
int *train_cases_gm;
cudaMalloc( (void **) &train_cases_gm, num_train_cases * (NUM_FEATURES + 1) * sizeof(int) );
int *level_train_cases = (int *) malloc(num_train_cases * (NUM_FEATURES + 1) * sizeof(int));
for(i = 0; i < num_train_cases; i++){
for(j = 0; j <= NUM_FEATURES; j++){
level_train_cases[i*(NUM_FEATURES+1)+j] = train_cases[(int)(alpha[1][i+1])][j];
}
}
cudaMemcpy( train_cases_gm, level_train_cases, num_train_cases * (NUM_FEATURES + 1) * sizeof(int), cudaMemcpyHostToDevice );
cudaMalloc( (void **) kernel_val_mat, num_train_cases * num_train_cases * sizeof(double) );
double *kernel_val_mat_cpu = (double *) malloc(num_train_cases * num_train_cases * sizeof(double));
double *opt_cond;
cudaMalloc( (void **) &opt_cond, num_train_cases * sizeof(double) );
double *opt_cond_cpu = (double *) malloc(num_train_cases * sizeof(double));
int num_blocks = (int) ceil((1.0*num_train_cases)/NUM_THREADS);
dim3 dimGrid(num_blocks);
dim3 dimBlock(NUM_THREADS);
cuda_svm_level_init<<< dimGrid, dimBlock >>>(alpha_gm, train_cases_gm, *kernel_val_mat,
opt_cond, gamma, num_train_cases, NUM_FEATURES, level);
cudaMemcpy( kernel_val_mat_cpu, *kernel_val_mat, num_train_cases*num_train_cases*sizeof(double), cudaMemcpyDeviceToHost );
for(i = 0; i < max_itr; i++){
cudaMemcpy( opt_cond_cpu, opt_cond, num_train_cases*sizeof(double), cudaMemcpyDeviceToHost );
bias_bound_index(&alpha[0][1], opt_cond_cpu, level_train_cases, num_train_cases,
NUM_FEATURES, C, &bias_low, &bias_high, &bias_low_indx, &bias_high_indx);
if( (bias_low - bias_high)/2 <= tol)
break;
/*cudaMemcpy( &kernel_val, &kernel_val_mat[bias_high_indx*num_train_cases+bias_low_indx],
sizeof(double), cudaMemcpyDeviceToHost );
eta = 2 * (1 - kernel_val);*/
eta = 2 * (1 - kernel_val_mat_cpu[bias_high_indx * num_train_cases + bias_low_indx]);
//to account for one count column in alpha
bias_high_indx++;
bias_low_indx++;
alpha_low_prev = alpha[0][bias_low_indx];
alpha_high_prev = alpha[0][bias_high_indx];
alpha[0][bias_low_indx] += level_train_cases[(bias_low_indx-1)*(NUM_FEATURES+1)] * (bias_high - bias_low) / eta;
if(alpha[0][bias_low_indx] < 0.0)
alpha[0][bias_low_indx] = 0.0;
else if (alpha[0][bias_low_indx] > C)
alpha[0][bias_low_indx] = C;
alpha[0][bias_high_indx] += level_train_cases[(bias_low_indx-1)*(NUM_FEATURES+1)] *
level_train_cases[(bias_high_indx-1)*(NUM_FEATURES+1)] * (alpha_low_prev - alpha[0][bias_low_indx]);
if(alpha[0][bias_high_indx] < 0.0)
alpha[0][bias_high_indx] = 0.0;
else if(alpha[0][bias_high_indx] > C)
alpha[0][bias_high_indx] = C;
opt_cond_itr<<< dimBlock, dimBlock >>>(num_train_cases, opt_cond, alpha[0][bias_high_indx], alpha_high_prev,
level_train_cases[(bias_high_indx-1)*(NUM_FEATURES+1)], bias_high_indx-1, alpha[0][bias_low_indx], alpha_low_prev,
level_train_cases[(bias_low_indx-1)*(NUM_FEATURES+1)], bias_low_indx-1, *kernel_val_mat);
}
//printf("Max Iter = %d\n",i);
*bias = (bias_low + bias_high) / 2;
cudaFree(alpha_gm);
cudaFree(train_cases_gm);
cudaFree(opt_cond);
free(level_train_cases);
free(kernel_val_mat_cpu);
free(opt_cond_cpu);
}
extern "C" void svm_test(double **alpha, double bias, int num_test_cases, int num_train_cases, int **train_cases, int test_start_indx,
int **test_cases, double gamma, int NUM_FEATURES, int *corr_pred_count){
int i, j = 1, num_SVs;
*corr_pred_count = 0;
for(i = 1; i <= num_train_cases; i++){
if(alpha[0][i] != 0.0){
alpha[0][j] = alpha[0][i];
alpha[1][j] = alpha[1][i];
j++;
}
}
num_SVs = j-1; //gives count of SVs.
alpha[0][0] = num_SVs;
alpha[1][0] = num_SVs;
int *SVs = (int *) malloc(num_SVs * (NUM_FEATURES + 1) * sizeof(int));
for(i = 0; i < num_SVs; i++){
for(j = 0; j <= NUM_FEATURES; j++){
SVs[i*(NUM_FEATURES+1)+j] = train_cases[(int)(alpha[1][i+1])][j];
}
}
double *alpha_gm;
cudaMalloc( (void **) &alpha_gm, num_SVs * sizeof(double) );
cudaMemcpy( alpha_gm, &alpha[0][1], num_SVs *sizeof(double), cudaMemcpyHostToDevice );
int *SVs_gm;
cudaMalloc( (void **) &SVs_gm, num_SVs * (NUM_FEATURES + 1) * sizeof(int) );
cudaMemcpy( SVs_gm, SVs, num_SVs * (NUM_FEATURES + 1) * sizeof(int), cudaMemcpyHostToDevice );
int *local_test_cases = (int *) malloc(num_test_cases * (NUM_FEATURES + 1) * sizeof(int));
for(i = 0; i < num_test_cases; i++){
for(j = 0; j <= NUM_FEATURES; j++){
local_test_cases[i*(NUM_FEATURES+1)+j] = test_cases[test_start_indx + i][j];
}
}
int *test_cases_gm;
cudaMalloc( (void **) &test_cases_gm, num_test_cases * (NUM_FEATURES + 1) * sizeof(int) );
cudaMemcpy( test_cases_gm, local_test_cases, num_test_cases * (NUM_FEATURES + 1) * sizeof(int), cudaMemcpyHostToDevice );
int *prediction;
cudaMalloc( (void **) &prediction, num_test_cases * sizeof(int));
int *prediction_cpu = (int *) malloc(num_test_cases * sizeof(int));
int num_blocks = (int) ceil(1.0*num_test_cases/NUM_THREADS);
dim3 dimGrid(num_blocks);
dim3 dimBlock(NUM_THREADS);
cuda_svm_test<<< dimGrid, dimBlock >>>(bias, num_SVs, alpha_gm, SVs_gm, prediction,
NUM_FEATURES, test_cases_gm, num_test_cases, gamma);
cudaMemcpy( prediction_cpu, prediction, num_test_cases * sizeof(int), cudaMemcpyDeviceToHost );
for(i = 0; i < num_test_cases; i++){
if(prediction_cpu[i] == test_cases[i][0]){
*corr_pred_count += 1;
}
}
cudaFree(alpha_gm);
cudaFree(SVs_gm);
cudaFree(test_cases_gm);
cudaFree(prediction);
free(SVs);
free(local_test_cases);
free(prediction_cpu);
}
__global__ void cuda_svm_level_init(double *alpha_gm, int *train_cases_gm, double *kernel_val_mat,
double *opt_cond, double gamma, int num_train_cases, int NUM_FEATURES, int level){
int i;
int global_id = blockIdx.x * blockDim.x + threadIdx.x;
double kernel_val, loc_opt_cond;
if(global_id < num_train_cases){
for(i = 0; i < num_train_cases; i++){
if(i == global_id){
kernel_val = 1.0;
}
else{
kernel_val = kernel_eval(&train_cases_gm[global_id*(NUM_FEATURES+1)],
&train_cases_gm[i*(NUM_FEATURES+1)], NUM_FEATURES, 1, gamma);
}
kernel_val_mat[global_id*num_train_cases+i] = kernel_val;
if(i == 0){
loc_opt_cond = - train_cases_gm[global_id*(NUM_FEATURES+1)];
}
if(level != 0){
loc_opt_cond += alpha_gm[i]*train_cases_gm[i*(NUM_FEATURES+1)]*kernel_val;
}
}
}
opt_cond[global_id] = loc_opt_cond;
}
__device__ double kernel_eval(int *arr1, int *arr2, int arr_len, int offset, double gamma){
double diff_norm_sqr = 0.0; // diff_norm_sqr is ||xi - xj||^2
int m = offset;
int n = offset;
while(m <= arr_len && n <= arr_len){
if(arr1[m] < arr2[n]){
diff_norm_sqr += 1;
m++;
}
else if(arr1[m] > arr2[n]){
diff_norm_sqr += 1;
n++;
}
else{
m++;
n++;
}
}
while(m <= arr_len){
diff_norm_sqr += 1;
m++;
}
while(n <= arr_len){
diff_norm_sqr +=1;
n++;
}
return exp(-gamma * diff_norm_sqr);
}
void bias_bound_index(double *alpha, double *opt_cond, int *train_cases, int num_train_cases, int NUM_FEATURES,
double C, double *bias_low, double *bias_high, int *bias_low_indx, int *bias_high_indx){
int j;
int bias_low_first_set = 0;
int bias_high_first_set = 0;
for(j = 0; j < num_train_cases; j++){
if( (alpha[j] > 0.0 && alpha[j] < C) ||
(train_cases[j*(NUM_FEATURES+1)] == 1 && alpha[j] == 0.0) ||
(train_cases[j*(NUM_FEATURES+1)] == -1 && alpha[j] == C) ){
if(bias_high_first_set == 0){
bias_high_first_set = 1;
*bias_high = opt_cond[j];
*bias_high_indx = j;
}
else if(*bias_high > opt_cond[j]){
*bias_high = opt_cond[j];
*bias_high_indx = j;
}
}
if( (alpha[j] > 0.0 && alpha[j] < C) ||
(train_cases[j*(NUM_FEATURES+1)] == 1 && alpha[j] == C) ||
(train_cases[j*(NUM_FEATURES+1)] == -1 && alpha[j] == 0.0)){
if(bias_low_first_set == 0){
bias_low_first_set = 1;
*bias_low = opt_cond[j];
*bias_low_indx = j;
}
else if(*bias_low < opt_cond[j]){
*bias_low = opt_cond[j];
*bias_low_indx = j;
}
}
}
}
__global__ void opt_cond_itr(int num_train_cases, double *opt_cond, double alpha_high, double alpha_high_prev,
int high_label, int high_indx, double alpha_low, double alpha_low_prev, int low_label,
int low_indx, double *kernel_val_mat){
int global_id = blockIdx.x * blockDim.x + threadIdx.x;
if(global_id < num_train_cases){
opt_cond[global_id] += (alpha_high - alpha_high_prev) * high_label * kernel_val_mat[high_indx*num_train_cases+global_id]
+ (alpha_low - alpha_low_prev) * low_label * kernel_val_mat[low_indx*num_train_cases+global_id];
}
}
__global__ void cuda_svm_test(double bias, int num_SVs, double *alpha_gm, int *SVs_gm, int *prediction,
int NUM_FEATURES, int *test_cases_gm, int num_test_cases, double gamma){
int i;
int global_id = blockIdx.x * blockDim.x + threadIdx.x;
double predict = bias;
if(global_id < num_test_cases){
for(i = 0; i < num_SVs; i++){
predict += ( alpha_gm[i] * SVs_gm[i*(NUM_FEATURES+1)] * kernel_eval(&SVs_gm[i*(NUM_FEATURES+1)],
&test_cases_gm[global_id*(NUM_FEATURES+1)], NUM_FEATURES, 1, gamma) );
}
prediction[global_id] = (predict > 0.0) ? 1 : -1;
}
}
|
10,246 |
/******************************************************************************
Copyright (c) 2016 Shuyang Sun
License: MIT
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <iostream>
#include <cstdio>
#ifdef __CUDACC__
__host__
void CheckCUDAErr(const std::initializer_list<const cudaError_t>& errors);
__host__
void PrintGPUDeviceInfo();
#endif
int main(int argc, const char* argv[]) {
#ifdef __CUDACC__
PrintGPUDeviceInfo();
#else
fprintf(stderr, "Error: please use nvcc to compile the program.");
#endif
return 0;
}
#ifdef __CUDACC__
__host__
void PrintGPUDeviceInfo() {
printf("------------------------------------------------------------------------------\n");
printf(" CUDA Device Info \n");
printf("------------------------------------------------------------------------------\n");
int device_count {};
CheckCUDAErr({cudaGetDeviceCount(&device_count)});
if (device_count == 0) {
fprintf(stderr, "No available CUDA device\n");
} else {
printf("Detected %u CUDA capable device%s\n", device_count, device_count <= 1 ? "" : "s");
for (unsigned int device_idx = 0; device_idx < device_count; ++device_idx) {
printf("\n");
cudaSetDevice(device_idx);
cudaDeviceProp device_prop {};
int driver_version {};
int runtime_version {};
CheckCUDAErr({
cudaGetDeviceProperties(&device_prop, device_idx),
cudaDriverGetVersion(&driver_version),
cudaRuntimeGetVersion(&runtime_version)
});
printf("Device %u: \"%s\"\n", device_idx, device_prop.name);
printf("\tCUDA driver / runtime version: %d.%d / %d.%d\n",
driver_version/1000, (driver_version%100)/10, runtime_version/1000, (runtime_version%100)/10);
printf("\tCUDA computing capability: %d.%d\n", device_prop.major, device_prop.minor);
printf("\tTotal amount of global memory: %.2f GB (%lu bytes)\n",
device_prop.totalGlobalMem/std::pow(1024.0f, 3.0f), device_prop.totalGlobalMem);
printf("\tGPU clock rate: %.2f GHz (%.0f MHz)\n",
device_prop.clockRate * 1e-6f, device_prop.clockRate * 1e-3f);
printf("\tMemory clock rate: %.2f GHz (%.0f MHz) \n",
device_prop.memoryClockRate * 1e-6f, device_prop.memoryClockRate * 1e-3f);
printf("\tMemory bus width : %d-bit\n",
device_prop.memoryBusWidth);
if (device_prop.l2CacheSize) {
printf("\tL2 cache size: %.2f MB (%d bytes)\n",
device_prop.l2CacheSize/std::pow(1024.0f, 2.0f), device_prop.l2CacheSize);
}
printf("\tMax texture dimension size (x, y, z):\n");
printf( "\t\t- 1D=(%d)\n"
"\t\t- 2D=(%d, %d)\n"
"\t\t- 3D=(%d, %d, %d)\n",
device_prop.maxTexture1D,
device_prop.maxTexture2D[0], device_prop.maxTexture2D[1],
device_prop.maxTexture3D[0], device_prop.maxTexture3D[1], device_prop.maxTexture3D[2]);
printf("\tMax layered texture size (dim) * layers:\n");
printf( "\t\t- 1D=(%d) * %d\n"
"\t\t- 2D=(%d, %d) * %d\n",
device_prop.maxTexture1DLayered[0], device_prop.maxTexture1DLayered[1],
device_prop.maxTexture2DLayered[0], device_prop.maxTexture2DLayered[1], device_prop.maxTexture2DLayered[2]);
printf("\tTotal amount of constant memory: %.2f KB (%lu bytes)\n",
device_prop.totalConstMem/1024.0f, device_prop.totalConstMem);
printf("\tTotal amount of shared memory per block: %.2f KB (%lu bytes)\n",
device_prop.sharedMemPerBlock/1024.0f, device_prop.sharedMemPerBlock);
printf("\tTotal number of registers available per block: %d\n",
device_prop.regsPerBlock);
printf("\tWarp size: %d\n",
device_prop.warpSize);
printf("\tSM (streaming multiprocessor) count: %d\n", device_prop.multiProcessorCount);
printf("\tWarps per SM: %d\n", static_cast<int>(std::ceil(device_prop.maxThreadsPerMultiProcessor/device_prop.warpSize)));
printf("\tMaximum number of threads per SM: %d\n", device_prop.maxThreadsPerMultiProcessor);
printf("\tMaximum number of threads per block: %d\n", device_prop.maxThreadsPerBlock);
printf("\tMaximum number of threads total: %d\n", device_prop.multiProcessorCount * device_prop.maxThreadsPerMultiProcessor);
printf("\tMaximum sizes of each dimension of a block: %d * %d * %d\n",
device_prop.maxThreadsDim[0], device_prop.maxThreadsDim[1], device_prop.maxThreadsDim[2]);
printf("\tMaximum sizes of each dimension of a grid: %d * %d * %d\n",
device_prop.maxGridSize[0], device_prop.maxGridSize[1], device_prop.maxGridSize[2]);
printf("\tMaximum memory pitch: %.2f GB (%lu bytes)\n",
device_prop.memPitch/std::pow(1024.0f, 3.0f), device_prop.memPitch);
}
}
printf("------------------------------------------------------------------------------\n");
}
__host__
void CheckCUDAErr(const std::initializer_list<const cudaError_t>& errors) {
#pragma unroll
for (auto err: errors) {
if (err != cudaSuccess) {
fprintf(stderr, "%s\n", cudaGetErrorString(err));
throw std::runtime_error {"CUDA error encountered."};
}
}
}
#endif
|
10,247 | #include <stdio.h>
#include <stdlib.h>
#include <thrust/device_vector.h>
#include <thrust/host_vector.h>
#include <thrust/copy.h>
#include <thrust/transform.h>
int main(int argc, char *argv[]) {
// declare variables
// float *hostInput1 = nullptr;
// float *hostInput2 = nullptr;
// float *hostOutput = nullptr;
thrust::host_vector<float> hostInput1;
thrust::host_vector<float> hostInput2;
thrust::host_vector<float> hostOutput;
int inputLength;
/* parse the input arguments */
//@@ Insert code here
// file pointers
FILE *input_file1 = fopen(argv[1],"r");
FILE *input_file2 = fopen(argv[2],"r");
FILE *e_output_file = fopen(argv[3],"r");
FILE *output_file = fopen(argv[4],"w");
// input length
fscanf(input_file1, "%d", &inputLength);
fscanf(input_file2, "%d", &inputLength);
// Import host input data
//@@ Read data from the raw files here
//@@ Insert code here
// hostInput1 = (float*) malloc(inputLength * sizeof(float));
// hostInput2 = (float*) malloc(inputLength * sizeof(float));
// fill host arrays
float readVal;
for (int i = 0; i < inputLength; ++i) {
fscanf(input_file1, "%f", &readVal);
hostInput1.push_back(readVal);
fscanf(input_file2, "%f", &readVal);
hostInput2.push_back(readVal);
hostOutput.push_back(0);
}
// Declare and allocate host output
//@@ Insert code here
// hostOutput = (float *) malloc(inputLength * sizeof(float));
// Declare and allocate thrust device input and output vectors
//@@ Insert code here
thrust::device_vector<float> deviceInput1(inputLength);
thrust::device_vector<float> deviceInput2(inputLength);
thrust::device_vector<float> deviceOutput(inputLength);
// Copy to device
//@@ Insert code here
thrust::copy(hostInput1.begin(), hostInput1.end(), deviceInput1.begin());
thrust::copy(hostInput2.begin(), hostInput2.end(), deviceInput2.begin());
// Execute vector addition
//@@ Insert Code here
thrust::transform(deviceInput1.begin(), deviceInput1.end(), deviceInput2.begin(), deviceOutput.begin(), thrust::plus<float>());
/////////////////////////////////////////////////////////
// Copy data back to host
//@@ Insert code here
thrust::copy(deviceOutput.begin(), deviceOutput.end(), hostOutput.begin());
// write result to expected output file
fprintf(output_file, "%d", inputLength);
for (int i = 0; i < inputLength; ++i) {
fprintf(output_file, "\n%.2f", hostOutput[i]);
}
// close file pointers
fclose(input_file1);
fclose(input_file2);
fclose(output_file);
fclose(e_output_file);
// check output difference
e_output_file = fopen(argv[3],"r");
output_file = fopen(argv[4],"r");
bool flag = false;
float read1, read2;
while (fscanf(e_output_file, "%f", &read1) != EOF) {
fscanf(output_file, "%f", &read2);
if (read1 != read2) {
flag = true;
break;
}
}
if (flag) {
printf("Outputs are different\n");
}
else {
printf("Outputs are the same\n");
}
fclose(output_file);
fclose(e_output_file);
// free(hostInput1);
// free(hostInput2);
// free(hostOutput);
return 0;
}
|
10,248 | /* Program : To perform matrix multiplication using shared memory
* Author : Anant Shah
* Roll Number : EE16B105
* Date : 7-9-2018
**/
#include<stdio.h>
#define ERROR_HANDLER(error_msg,line) error_handler(error_msg,line)
#define SIZE 32
#define NUM_THREADS_X 16
#define NUM_THREADS_Y 16
void error_handler(cudaError_t error_msg,int line){
/* Error handler function */
if( error_msg!=cudaSuccess ){
printf("%s in %s at %d",cudaGetErrorString(error_msg),__FILE__,line);
exit(EXIT_FAILURE);
}
}
void fill_matrix(double *mat, unsigned numRows, unsigned numCols){
/*Program to fill the elements of a matrix with the given number of rows and columns */
for(unsigned i=0;i<numRows;i++){
for(unsigned j=0;j<numCols;j++){
mat[i*numCols+j] = i*2.1f+j*3.2f;
}
}
}
void print_matrix_to_file(double *mat, unsigned numRows, unsigned numCols){
/* Function to print the matrix elements into a file */
const char *fname = "assignment2_out";
FILE *f = fopen(fname,"a");
for(unsigned i=0; i<numRows; i++){
for(unsigned j=0;j<numCols;j++){
fprintf(f,"%4.4f ",mat[i*numCols+j]);
}
fprintf(f,"\n");
}
fclose(f);
}
__global__ void matrixMul(double *M,double *N,double *P,int width){
/* Kernel to perform the matrix multiplication output for each cell
* Shared Memory on the SM will be utilized for each thread
* Parameters : M - Matrix multiplicand
* N - matrix Multiplicand
* P - Output of the product M*N
* width - Dimensions of the square matrices
*/
int tx = threadIdx.x; /* x-ID of a thread in a block */
int ty = threadIdx.y; /* y-ID of a thread in a block */
int Row = blockIdx.y*blockDim.y+ty; /* Row of the cell in the output matrix */
int Col = blockIdx.x*blockDim.x+tx; /* Row of the cell in the input matrix */
/* Declaring array variables in the shared memory to be used by the threads to perform the matrix multiplication */
__shared__ double Ms[NUM_THREADS_Y][SIZE]; /* A 2-D array to store the variables required by a block from matrix M */
__shared__ double Ns[SIZE][NUM_THREADS_X]; /* A 2-D array to store the variables required by a block from matrix N */
/* Loading the matrices from the global memory to the shared memory by collaborative loading */
int num_col_cells = (width+blockDim.x-1)/blockDim.x; /* Number of cells to be stored from matrix M in global memory for a given cell in the outpt matrix*/
int num_row_cells = (width+blockDim.y-1)/blockDim.y; /* Number of cells to be stored from matrix N in global memory for a given cell in the output matrix */
/*Since for this case, we are taking the square matrix to be a block, num_col_cells = num_row_cells and hence both the loading operations can be completed in the same probelm */
for(int i=0;i<num_col_cells;i++){
Ms[ty][tx*num_col_cells+i] = M[Row*width+tx*num_col_cells+i];
Ns[ty*num_row_cells+i][tx] = N[(ty*num_row_cells+i)*width+Col];
}
__syncthreads(); /*All threads in the block need to finish loading before we can proceed with the multiplication */
/*The partial matrices have been stored in the shared memory, we now need to perform matrix multiplication */
double pSum=0.0; /*Partial sum to store the multiplication */
for(int i=0;i<width;i++){
pSum += Ms[ty][i]*Ns[i][tx];
}
P[Row*width+Col] = pSum;
}
int main(int argc,char **argv){
if(argc!=1){
printf("Error : Invalid number of arguments");
exit(EXIT_FAILURE);
}
/******************************** Variable Declarations ***************************************************/
double *h_M; /* Matrix multiplicand M on the host */
double *h_N; /* Matrix multiplicand N on the host */
double *h_P; /* Matrix product(M*N) on the host */
double *d_M; /* Matrix multiplicand M on the device */
double *d_N; /* Matrix multiplicand N on the device */
double *d_P; /* Matrix product(M*N) on the device */
size_t size; /* The size in bytes of each matrix */
cudaEvent_t start,stop; /* Cuda Events to measure the run-time of the kernel */
cudaEventCreate(&start);
cudaEventCreate(&stop);
size = sizeof(double)*SIZE*SIZE; /* These are square matrices of dimensions SIZE*SIZE */
/******************************** Allocate Memory on the host *********************************************/
h_M = (double *)malloc(size);
h_N = (double *)malloc(size);
h_P = (double *)malloc(size);
/******************************** Initialize the matrices ************************************************/
fill_matrix(h_M,SIZE,SIZE);
fill_matrix(h_N,SIZE,SIZE);
/******************************** Allocate Memory on the device ******************************************/
ERROR_HANDLER(cudaMalloc((void **)&d_M,size),__LINE__);
ERROR_HANDLER(cudaMalloc((void **)&d_N,size),__LINE__);
ERROR_HANDLER(cudaMalloc((void **)&d_P,size),__LINE__);
/******************************* Copy matrices from host to device **************************************/
ERROR_HANDLER(cudaMemcpy(d_M,h_M,size,cudaMemcpyHostToDevice),__LINE__);
ERROR_HANDLER(cudaMemcpy(d_N,h_N,size,cudaMemcpyHostToDevice),__LINE__);
/****************************** Kernel Invocation *******************************************************/
dim3 threads(NUM_THREADS_X,NUM_THREADS_Y);
dim3 blocks((SIZE+NUM_THREADS_X-1)/NUM_THREADS_X,(SIZE+NUM_THREADS_Y-1)/NUM_THREADS_Y);
cudaEventRecord(start);
matrixMul<<<blocks,threads>>>(d_M,d_N,d_P,SIZE);
cudaEventRecord(stop);
ERROR_HANDLER(cudaMemcpy(h_P,d_P,size,cudaMemcpyDeviceToHost),__LINE__);
cudaEventSynchronize(stop);
float milliseconds = 0.0;
cudaEventElapsedTime(&milliseconds, start, stop);
printf("Run-Time(milli-seconds) : %.10f \n",milliseconds);
print_matrix_to_file(h_P,SIZE,SIZE);
/***************************** Free the memory that was allocated **************************************/
cudaFree(d_M);
cudaFree(d_N);
cudaFree(d_P);
free(h_M);
free(h_N);
free(h_P);
}
|
10,249 | #include <cuda.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#define gpuErrchk(ans) { gpuAssert((ans), __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);
}
}
/*****************************************************************/
typedef struct FmapShape
{
unsigned int C;
unsigned int W;
} FmapShape;
typedef struct FilterShape
{
unsigned int C;
unsigned int M;
unsigned int K;
} FilterShape;
// Function declarations: Feel free to add any functions you want.
__host__ __device__ unsigned int get_fmap_index(unsigned int d1, unsigned int d2, unsigned int d3, FmapShape fmap_shape){
// Input shape: C*W*W
return d1 * fmap_shape.W * fmap_shape.W + d2 * fmap_shape.W + d3;
}
__host__ __device__ unsigned int get_filter_index(unsigned int d1, unsigned int d2, unsigned int d3, unsigned int d4, FilterShape filter_shape){
// Filter shape: C*M*K*K
return d1 * filter_shape.M * filter_shape.K * filter_shape.K + d2 * filter_shape.K * filter_shape.K + d3 * filter_shape.K + d4;
}
void cpu_deconv(float *, float *, float *, FmapShape, FilterShape, FmapShape);
void cpu_deconv_group_by_ofmap(float *, float *, float *, FmapShape, FilterShape, FmapShape);
void gpu_deconv(float *, float *, float *, FmapShape, FilterShape, FmapShape, unsigned int, unsigned int);
void calc_flops(double, unsigned int, unsigned int);
void print_fmap(float *, FmapShape);
__global__ void deconv_kernel(float *, float *, float *, FmapShape, FilterShape, FmapShape);
template<int,int,int> __global__ void deconv_kernel_share_filter_tiled(float *, float *, float *, FmapShape, FilterShape, FmapShape, int);
template<int> __global__ void deconv_kernel_group_by_ofmap(float *, float *, float *, FmapShape, FilterShape, FmapShape);
/*****************************************************************/
// to measure time taken by a specific part of the code
double seconds;
clock_t start, end;
int main(int argc, char * argv[])
{
// layer parameters
unsigned int W, C, M, K;
K = 4; // kernel size fixed: 4x4
// decides which algorithm to use
int option = atoi(argv[1]);
// decides layer parameters
int layer = atoi(argv[2]);
if (layer == 0) {
C = 512;
M = 256;
W = 4;
}
else if (layer == 1) {
C = 256;
M = 128;
W = 8;
}
else if (layer == 2) {
C = 128;
M = 64;
W = 16;
}
else if (layer == 3) {
C = 64;
M = 3;
W = 32;
}
else {
printf("layer not found\n");
exit(1);
}
printf("layer %d: C=%d M=%d W=%d K=%d\n", layer, C, M, W, K);
FmapShape ifmap_shape;
ifmap_shape.C = C;
ifmap_shape.W = W;
FilterShape filter_shape;
filter_shape.C = C;
filter_shape.M = M;
filter_shape.K = K;
FmapShape ofmap_shape;
ofmap_shape.C = M;
ofmap_shape.W = 2*W;
/* The 3D array of points will be treated as 1D array of CxWxW elements */
float * ifmap, * filter, * ofmap_cpu, * ofmap_gpu;
/* Dynamically allocate NxN array of floats */
ifmap = (float *)calloc(C*W*W, sizeof(float));
filter = (float *)calloc(C*M*K*K, sizeof(float));
ofmap_cpu = (float *)calloc(4*M*W*W, sizeof(float));
ofmap_gpu = (float *)calloc(4*M*W*W, sizeof(float));
printf("ifmap size=%d, ", C*W*W);
printf("filter size=%d, ", C*M*K*K);
printf("ofmap size=%d\n", 4*M*W*W);
// return 0;
/* Initialize it: calloc already initalized everything to 0 */
for(int i = 0; i < C*W*W; i++)
ifmap[i] = i*0.00001;
for(int i = 0; i < C*M*K*K; i++)
filter[i] = i*0.00001;
// for(int i = 0; i < 4*M*W*W; i++)
// ofmap_cpu[i] = 0.0;
// for(int i = 0; i < 4*M*W*W; i++)
// ofmap_gpu[i] = 0.0;
int nIter = 1000;
// nIter = 1;
if (option == 0)
cpu_deconv(ifmap, filter, ofmap_cpu, ifmap_shape, filter_shape, ofmap_shape);
else if (option == 1)
cpu_deconv_group_by_ofmap(ifmap, filter, ofmap_cpu, ifmap_shape, filter_shape, ofmap_shape);
else
gpu_deconv(ifmap, filter, ofmap_gpu, ifmap_shape, filter_shape, ofmap_shape, nIter, option);
// check correctness
// if (nIter == 1) {
// cpu_deconv(ifmap, filter, ofmap_cpu, ifmap_shape, filter_shape, ofmap_shape);
// double diff = 0, sum = 0;
// for (int i=0; i<4*M*W*W; i++) {
// sum += ofmap_cpu[i];
// diff += (ofmap_gpu[i] - ofmap_cpu[i]);
// }
// printf("sum: %f\n", sum);
// printf("diff: %f\n", abs(diff));
// printf("diff to sum ratio: %f\n", abs(diff) / sum);
// // print_fmap(ofmap_cpu, ofmap_shape);
// // print_fmap(ofmap_gpu, ofmap_shape);
// }
free(ifmap);
free(filter);
free(ofmap_cpu);
free(ofmap_gpu);
return 0;
}
void cpu_deconv(float * ifmap, float * filter, float * ofmap,
FmapShape ifmap_shape, FilterShape filter_shape, FmapShape ofmap_shape)
{
start = clock();
unsigned int pad = (filter_shape.K - 1) / 2;
int nIter = 10;
for (int i=0; i<nIter; ++i) {
// assuming stride is always 2, batch size is always 1
for (int c=0; c<ifmap_shape.C; c++){
for (int w0=0; w0<ifmap_shape.W; w0++){
for (int w1=0; w1<ifmap_shape.W; w1++){
for (int m=0; m<filter_shape.M; m++){
for (int k0=0; k0<filter_shape.K; k0++){
for (int k1=0; k1<filter_shape.K; k1++){
int output_y = w0*2+k0-pad;
int output_x = w1*2+k1-pad;
if (output_x >= 0 && output_y >= 0 && output_x < ofmap_shape.W && output_y < ofmap_shape.W){
unsigned int ifmap_index = get_fmap_index(c, w0, w1, ifmap_shape);
unsigned int filter_index = get_filter_index(c, m, k0, k1, filter_shape);
unsigned int ofmap_index = get_fmap_index(m, output_y, output_x, ofmap_shape);
ofmap[ofmap_index] += ifmap[ifmap_index] * filter[filter_index];
}
}
}
}
}
}
}
}
end = clock();
seconds = ((double)(end - start))/ CLOCKS_PER_SEC;
unsigned int opsPerConvTranspose = 2 * ifmap_shape.C *ifmap_shape.W * ifmap_shape.W *
filter_shape.M * filter_shape.K * filter_shape.K;
calc_flops(seconds, opsPerConvTranspose, nIter);
}
void cpu_deconv_group_by_ofmap(float * ifmap, float * filter, float * ofmap,
FmapShape ifmap_shape, FilterShape filter_shape, FmapShape ofmap_shape)
{
start = clock();
// assuming stride is always 2, batch size is always 1
unsigned int pad = (filter_shape.K - 1) / 2;
int nIter = 10;
for (int i=0; i<nIter; ++i) {
for (int m=0; m<ofmap_shape.C; m++) {
for (int p0=0; p0<ofmap_shape.W; p0++) {
for (int p1=0; p1<ofmap_shape.W; p1++) {
float ofmap_local = 0;
for (int c=0; c<ifmap_shape.C; c++) {
for (int w0=0; w0<ifmap_shape.W; w0++) {
for (int w1=0; w1<ifmap_shape.W; w1++) {
int k0 = p0 - w0*2 + pad;
int k1 = p1 - w1*2 + pad;
if (k0 >= 0 && k0 < filter_shape.K && k1 >= 0 && k1 < filter_shape.K) {
unsigned int ifmap_index = get_fmap_index(c, w0, w1, ifmap_shape);
unsigned int filter_index = get_filter_index(c, m, k0, k1, filter_shape);
ofmap_local += ifmap[ifmap_index] * filter[filter_index];
}
}
}
}
int ofmap_index = get_fmap_index(m, p0, p1, ofmap_shape);
ofmap[ofmap_index] = ofmap_local;
}
}
}
}
end = clock();
seconds = ((double)(end - start))/ CLOCKS_PER_SEC;
unsigned int opsPerConvTranspose = 2 * ifmap_shape.C *ifmap_shape.W * ifmap_shape.W *
filter_shape.M * filter_shape.K * filter_shape.K;
calc_flops(seconds, opsPerConvTranspose, nIter);
}
__global__
void deconv_kernel(float * ifmap, float * filter, float * ofmap,
FmapShape ifmap_shape, FilterShape filter_shape, FmapShape ofmap_shape)
{
// assuming stride is always 2
unsigned int thread_index = blockIdx.x * blockDim.x + threadIdx.x;
unsigned int c = thread_index / (ifmap_shape.W * ifmap_shape.W);
unsigned int w0 = thread_index % (ifmap_shape.W * ifmap_shape.W) / ifmap_shape.W;
unsigned int w1 = thread_index % ifmap_shape.W;
unsigned int pad = (filter_shape.K - 1) / 2;
for (int m=0; m<filter_shape.M; m++){
for (int k0=0; k0<filter_shape.K; k0++){
for (int k1=0; k1<filter_shape.K; k1++){
int output_y = w0*2+k0-pad;
int output_x = w1*2+k1-pad;
if (output_x >= 0 && output_y >= 0 && output_x < ofmap_shape.W && output_y < ofmap_shape.W){
unsigned int ifmap_index = get_fmap_index(c, w0, w1, ifmap_shape);
unsigned int filter_index = get_filter_index(c, m, k0, k1, filter_shape);
unsigned int ofmap_index = get_fmap_index(m, output_y, output_x, ofmap_shape);
//ofmap[ofmap_index] += ifmap[ifmap_index] * filter[filter_index];
atomicAdd(&ofmap[ofmap_index], ifmap[ifmap_index] * filter[filter_index]);
}
}
}
}
}
// share filter & input
template<int Tm, int K, int W>
__global__
void deconv_kernel_share_filter_tiled(float * ifmap, float * filter, float * ofmap,
FmapShape ifmap_shape, FilterShape filter_shape, FmapShape ofmap_shape, int m_offset)
{
unsigned int w0 = threadIdx.x % (ifmap_shape.W * ifmap_shape.W) / ifmap_shape.W;
unsigned int w1 = threadIdx.x % ifmap_shape.W;
unsigned int pad = (filter_shape.K - 1) / 2;
// process one input channel per block
unsigned int c = blockIdx.x;
// assume num of threads is a multiple of W*W, each thread should be responsible for multiple m's
unsigned int m_parallel = blockDim.x / (ifmap_shape.W * ifmap_shape.W);
unsigned int m_per_thread = (Tm + m_parallel - 1)/ m_parallel;
__shared__ float filter_shared[Tm][K][K];
for (int i = threadIdx.x; i < Tm*K*K; i += blockDim.x) {
unsigned int filter_m = i / (filter_shape.K * filter_shape.K);
unsigned int filter_k0 = i % (filter_shape.K * filter_shape.K) / filter_shape.K;
unsigned int filter_k1 = i % filter_shape.K;
filter_shared[filter_m][filter_k0][filter_k1] = filter[get_filter_index(c, m_offset+filter_m, filter_k0, filter_k1, filter_shape)];
}
__shared__ float ofmap_shared[Tm][2*W][2*W];
for (int i = threadIdx.x; i < Tm*2*W*2*W; i += blockDim.x) {
unsigned int ofmap_m = i / (ofmap_shape.W * ofmap_shape.W);
unsigned int ofmap_w0 = i % (ofmap_shape.W * ofmap_shape.W) / ofmap_shape.W;
unsigned int ofmap_w1 = i % ofmap_shape.W;
ofmap_shared[ofmap_m][ofmap_w0][ofmap_w1] = 0;
}
__syncthreads();
unsigned int m = threadIdx.x / (ifmap_shape.W * ifmap_shape.W);
unsigned int ifmap_index = get_fmap_index(c, w0, w1, ifmap_shape);
// divide the output window per filter into 4 blocks to avoid memory access conflicts
for (int b0=0; b0<2; b0++){
for (int b1=0; b1<2; b1++){
for (int mm=m_per_thread*m; mm<m_per_thread*(m+1); mm++){
for (int k0=b0*2; k0<(b0+1)*2; k0++){
for (int k1=b1*2; k1<(b1+1)*2; k1++){
int output_y = w0*2+k0-pad;
int output_x = w1*2+k1-pad;
if (output_x >= 0 && output_y >= 0 && output_x < ofmap_shape.W && output_y < ofmap_shape.W && mm<Tm){
ofmap_shared[mm][output_y][output_x] += ifmap[ifmap_index] * filter_shared[mm][k0][k1];
}
}
}
}
__syncthreads();
}
}
for (int i = threadIdx.x; i < Tm*2*W*2*W; i += blockDim.x) {
unsigned int ofmap_m = i / (ofmap_shape.W * ofmap_shape.W);
unsigned int ofmap_w0 = i % (ofmap_shape.W * ofmap_shape.W) / ofmap_shape.W;
unsigned int ofmap_w1 = i % ofmap_shape.W;
atomicAdd(&ofmap[get_fmap_index(m_offset+ofmap_m, ofmap_w0, ofmap_w1, ofmap_shape)], ofmap_shared[ofmap_m][ofmap_w0][ofmap_w1]);
}
}
template<int IFMAP_SIZE>
__global__
void deconv_kernel_group_by_ofmap(float * ifmap, float * filter, float * ofmap,
FmapShape ifmap_shape, FilterShape filter_shape, FmapShape ofmap_shape)
{
unsigned int m = blockIdx.x;
unsigned int p0 = threadIdx.x;
unsigned int p1 = threadIdx.y;
// assuming stride is always 2, batch size is always 1
unsigned int pad = (filter_shape.K - 1) / 2;
__shared__ float ifmap_shared[IFMAP_SIZE][IFMAP_SIZE];
float ofmap_local = 0;
for (int c=0; c<ifmap_shape.C; c++) {
if (p0 == 0 && p1 == 0) {
#pragma unroll
for (int i=0; i<IFMAP_SIZE; ++i) {
#pragma unroll
for (int j=0; j<IFMAP_SIZE; ++j) {
ifmap_shared[i][j] = ifmap[get_fmap_index(c, i, j, ifmap_shape)];
}
}
}
__syncthreads();
for (int w0=0; w0<ifmap_shape.W; w0++) {
for (int w1=0; w1<ifmap_shape.W; w1++) {
int k0 = p0 - w0*2 + pad;
int k1 = p1 - w1*2 + pad;
if (k0 >= 0 && k0 < filter_shape.K && k1 >= 0 && k1 < filter_shape.K) {
ofmap_local += ifmap_shared[w0][w1] * filter[get_filter_index(c, m, k0, k1, filter_shape)];
}
}
}
}
int ofmap_index = get_fmap_index(m, p0, p1, ofmap_shape);
ofmap[ofmap_index] = ofmap_local;
}
void gpu_deconv(float * ifmap, float * filter, float * ofmap,
FmapShape ifmap_shape, FilterShape filter_shape, FmapShape ofmap_shape,
unsigned int nIter, unsigned int option)
{
float * d_ifmap, * d_filter, * d_ofmap;
size_t ifmap_size = ifmap_shape.C*ifmap_shape.W*ifmap_shape.W*sizeof(float);
size_t filter_size = filter_shape.C*filter_shape.M*filter_shape.K*filter_shape.K*sizeof(float);
size_t ofmap_size = ofmap_shape.C*ofmap_shape.W*ofmap_shape.W*sizeof(float);
gpuErrchk(cudaMalloc(&d_ifmap, ifmap_size));
gpuErrchk(cudaMalloc(&d_filter, filter_size));
gpuErrchk(cudaMalloc(&d_ofmap, ofmap_size));
gpuErrchk(cudaMemcpy(d_ifmap, ifmap, ifmap_size, cudaMemcpyHostToDevice));
gpuErrchk(cudaMemcpy(d_filter, filter, filter_size, cudaMemcpyHostToDevice));
gpuErrchk(cudaMemcpy(d_ofmap, ofmap, ofmap_size, cudaMemcpyHostToDevice));
start = clock();
// naive impl
if (option == 2) {
int nBlocks = ceil(1.0*ifmap_shape.C*ifmap_shape.W*ifmap_shape.W)/1024;
for (int j=0; j<nIter; ++j) {
deconv_kernel <<< nBlocks, 1024 >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape);
}
}
// shared filter/ofmap + tiling
else if (option == 3) {
unsigned int threads = 1024;
dim3 grid(filter_shape.C);
for (int j=0; j<nIter; ++j) {
if (filter_shape.M == 256) {
// M = 256, W = 4, Tm = 150, remaining Tm = 106
const unsigned int W = 4;
const unsigned int Tm = 150;
const unsigned int remaining_Tm = 106; // M % Tm
for (int k=0; k<(filter_shape.M+Tm-1)/Tm-1; ++k) {
deconv_kernel_share_filter_tiled<Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, k*Tm);
}
deconv_kernel_share_filter_tiled<remaining_Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, ((filter_shape.M+Tm-1)/Tm-1)*Tm);
}
else if (filter_shape.M == 128) {
// M = 128, W = 8, Tm = 45, remaining Tm = 38
const unsigned int W = 8;
const unsigned int Tm = 45;
const unsigned int remaining_Tm = 38; // M % Tm
for (int k=0; k<(filter_shape.M+Tm-1)/Tm-1; ++k) {
deconv_kernel_share_filter_tiled<Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, k*Tm);
}
deconv_kernel_share_filter_tiled<remaining_Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, ((filter_shape.M+Tm-1)/Tm-1)*Tm);
}
else if (filter_shape.M == 64) {
// M = 64, W = 16, Tm = 10, remaining Tm = 4
const unsigned int W = 16;
const unsigned int Tm = 10;
const unsigned int remaining_Tm = 4; // M % Tm
for (int k=0; k<(filter_shape.M+Tm-1)/Tm-1; ++k) {
deconv_kernel_share_filter_tiled<Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, k*Tm);
}
deconv_kernel_share_filter_tiled<remaining_Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, ((filter_shape.M+Tm-1)/Tm-1)*Tm);
}
else if (filter_shape.M == 3) {
// M = 3, W = 32, Tm = 2, remaining Tm = 1
const unsigned int W = 32;
const unsigned int Tm = 2;
const unsigned int remaining_Tm = 1; // M % Tm
for (int k=0; k<(filter_shape.M+Tm-1)/Tm-1; ++k) {
deconv_kernel_share_filter_tiled<Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, k*Tm);
}
deconv_kernel_share_filter_tiled<remaining_Tm, 4, W> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape, ((filter_shape.M+Tm-1)/Tm-1)*Tm);
}
else {
printf("layer not found\n");
gpuErrchk(cudaFree(d_ifmap));
gpuErrchk(cudaFree(d_filter));
gpuErrchk(cudaFree(d_ofmap));
exit(1);
}
}
}
// group by ofmap
else if (option == 4) {
dim3 threads(ofmap_shape.W, ofmap_shape.W);
dim3 grid(ofmap_shape.C);
for (int j=0; j<nIter; ++j) {
if (ofmap_shape.W == 8) {
deconv_kernel_group_by_ofmap<8> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape);
}
else if (ofmap_shape.W == 16) {
deconv_kernel_group_by_ofmap<16> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape);
}
else if (ofmap_shape.W == 32) {
deconv_kernel_group_by_ofmap<32> <<< grid, threads >>>
(d_ifmap, d_filter, d_ofmap, ifmap_shape, filter_shape, ofmap_shape);
}
else if (ofmap_shape.W == 64) {
printf("layer not supported: ofmap shape too large\n");
gpuErrchk(cudaFree(d_ifmap));
gpuErrchk(cudaFree(d_filter));
gpuErrchk(cudaFree(d_ofmap));
exit(1);
}
else {
printf("layer not found\n");
gpuErrchk(cudaFree(d_ifmap));
gpuErrchk(cudaFree(d_filter));
gpuErrchk(cudaFree(d_ofmap));
exit(1);
}
}
}
gpuErrchk(cudaDeviceSynchronize());
end = clock();
seconds = ((double)(end - start))/ CLOCKS_PER_SEC;
unsigned int opsPerConvTranspose = 2 * ifmap_shape.C *ifmap_shape.W * ifmap_shape.W *
filter_shape.M * filter_shape.K * filter_shape.K;
calc_flops(seconds, opsPerConvTranspose, nIter);
gpuErrchk(cudaMemcpy(ofmap, d_ofmap, ofmap_size, cudaMemcpyDeviceToHost));
gpuErrchk(cudaFree(d_ifmap));
gpuErrchk(cudaFree(d_filter));
gpuErrchk(cudaFree(d_ofmap));
}
void calc_flops(double seconds, unsigned int opsPerConvTranspose, unsigned int nIter) {
double gigaFlops = 1.0 * (opsPerConvTranspose * 1.0e-9f) * nIter / seconds;
printf("Iterations=%d, Total Time=%.2f seconds, Ops per Iteration=%d\n\n", nIter, seconds, opsPerConvTranspose);
printf("Performance=%.3f GFlops/sec\n", gigaFlops);
printf("Average time per iteration=%.2f msec\n\n", seconds * 1000 / nIter);
}
void print_fmap(float * fmap, FmapShape fmap_shape) {
printf("%d %d %d\n", fmap_shape.C, fmap_shape.W, fmap_shape.W);
for (int c = 0; c < fmap_shape.C; c++) {
for (int w0 = 0; w0 < fmap_shape.W; w0++) {
for (int w1 = 0; w1 < fmap_shape.W; w1++) {
unsigned int fmap_index = get_fmap_index(c, w0, w1, fmap_shape);
printf("%f ", fmap[fmap_index]);
}
printf("\n");
}
printf("\n");
}
}
|
10,250 | #include <stdio.h>
#include <stdlib.h>
inline void check_cuda_errors(const char *filename, const int line_number) {
#ifdef DEBUG
cudaThreadSynchronize();
cudaError_t error = cudaGetLastError();
if (error != cudaSuccess) {
printf("CUDA error at %s:%i: %s\n", filename, line_number,
cudaGetErrorString(error));
exit(-1);
}
#endif
}
__global__ void foo(int *ptr) { *ptr = 7; }
int main(void) {
foo<<<1, 1>>>(0);
check_cuda_errors(__FILE__, __LINE__);
return 0;
}
|
10,251 | /*I have taken the help of lzhengchun/matrix-cuda github repository to get this code working.*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include<time.h>
#define BLOCK_SIZE 16
__global__ void g_mat_mul(int *a,int *b, int *c, int m, int n, int k)
{
int r = blockIdx.y * blockDim.y + threadIdx.y;
int cl = blockIdx.x * blockDim.x + threadIdx.x;
int temp = 0;
if( cl < k && r < m)
{
for(int i = 0; i < n; i++)
{
temp += a[r * n + i] * b[i * k + cl];
}
c[r * k + cl] = temp;
}
}
int main(int argc, char const *argv[])
{
int m_rows, n_col_row, k_col;
printf("please type in A=mxn B=nxk \n");
scanf("%d %d %d", &m_rows, &n_col_row, &k_col);
int *h_a_cpu, *h_b_cpu, *h_c_cpu, *h_cc_cpu;
cudaMallocHost((void **) &h_a_cpu, sizeof(int)*m_rows*n_col_row);
cudaMallocHost((void **) &h_b_cpu, sizeof(int)*n_col_row*k_col);
cudaMallocHost((void **) &h_c_cpu, sizeof(int)*m_rows*k_col);
cudaMallocHost((void **) &h_cc_cpu, sizeof(int)*m_rows*k_col);
for (int i = 0; i < m_rows; ++i) {
for (int j = 0; j < n_col_row; ++j) {
h_a_cpu[i * n_col_row + j] = rand() % 1024;
}
}
for (int i = 0; i < n_col_row; ++i) {
for (int j = 0; j < k_col; ++j) {
h_b_cpu[i * k_col + j] = rand() % 1024;
}
}
float gpu_elapsed_time_ms, cpu_elapsed_time_ms;
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start, 0);
int *d_a_gpu, *d_b_gpu, *d_c_gpu;
cudaMalloc((void **) &d_a_gpu, sizeof(int)*m_rows*n_col_row);
cudaMalloc((void **) &d_b_gpu, sizeof(int)*n_col_row*k_col);
cudaMalloc((void **) &d_c_gpu, sizeof(int)*m_rows*k_col);
cudaMemcpy(d_a_gpu, h_a_cpu, sizeof(int)*m_rows*n_col_row, cudaMemcpyHostToDevice);
cudaMemcpy(d_b_gpu, h_b_cpu, sizeof(int)*n_col_row*k_col, cudaMemcpyHostToDevice);
unsigned int grid_rows = (m_rows + BLOCK_SIZE - 1) / BLOCK_SIZE;
unsigned int grid_cols = (k_col + BLOCK_SIZE - 1) / BLOCK_SIZE;
dim3 dimGrid(grid_cols, grid_rows);
dim3 dimBlock(BLOCK_SIZE, BLOCK_SIZE);
g_mat_mul<<<dimGrid, dimBlock>>>(d_a_gpu, d_b_gpu, d_c_gpu, m_rows, n_col_row, k_col);
cudaMemcpy(h_a_cpu, d_c_gpu, sizeof(int)*m_rows*k_col, cudaMemcpyDeviceToHost);
cudaThreadSynchronize();
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
cudaEventElapsedTime(&gpu_elapsed_time_ms, start, stop);
printf("Time elapsed on matrix multiplication of %dx%d . %dx%d on GPU: %f ms.\n\n", m_rows, n_col_row, n_col_row, k_col, gpu_elapsed_time_ms);
cudaFree(d_a_gpu);
cudaFree(d_b_gpu);
cudaFree(d_c_gpu);
cudaFreeHost(h_a_cpu);
cudaFreeHost(h_b_cpu);
cudaFreeHost(h_c_cpu);
cudaFreeHost(h_cc_cpu);
return 0;
}
|
10,252 | #include "includes.h"
#define CUDA_KERNEL_LOOP(i ,n) \
for (int i = blockIdx.x * blockDim.x + threadIdx.x; i<(n); i+= blockDim.x * gridDim.x)
const int CUDA_NUM_THREADS = 1024;
__global__ void calculate_dbias_kernel( int n, const float* grad_output, float* grad_bias, const int out_channels, const int height_out, const int width_out ){
CUDA_KERNEL_LOOP(index, n){
const int c_col = (index / width_out / height_out) % out_channels;
float value = grad_output[index];
atomicAdd(grad_bias + c_col, value);
}
} |
10,253 | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <ctime>
cudaError_t addWithCuda(int* c, const int* a, const int* b, unsigned int size);
__global__ void addKernel(int* c, const int* a, const int* b)
{
int i = threadIdx.x;
c[i] = a[i] + b[i];
}
struct TestNode
{
float x[36];
float* y;
};
struct TestNode2
{
float x[36];
float y[6];
};
__global__ void copy_test(TestNode* arr2, float* temp, int len)
{
unsigned idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < len)
{
arr2[idx].y = temp + 6 * idx;
// arr2[idx].y[0] = 0;
// arr2[idx].y[5] = 6;
}
}
void cudaTestMemory()
{
const int size = 9000 * 1024;
cudaError_t cudaStatus;
cudaStatus = cudaSetDevice(0);
TestNode2* arr;
TestNode* arr2;
float* temp;
clock_t start = clock();
cudaStatus = cudaMalloc(&arr, size * sizeof(TestNode2));
if (cudaStatus != cudaSuccess)
{
fprintf(stderr, "cudaMalloc failed! 0");
}
printf("time %d", (clock() - start));
cudaFree(arr);
start = clock();
cudaStatus = cudaMalloc((void**)&arr2, size * sizeof(TestNode));
if (cudaStatus != cudaSuccess)
{
fprintf(stderr, "cudaMalloc failed! 1 ");
}
cudaStatus = cudaMalloc((void**)&temp, size * 6 * sizeof(float));
if (cudaStatus != cudaSuccess)
{
fprintf(stderr, "cudaMalloc failed! 2");
}
copy_test<<<size / 1024,1024>>>(arr2, temp, size);
if (cudaStatus != cudaSuccess)
{
fprintf(stderr, "kernel failed!");
}
cudaDeviceSynchronize();
printf("time %d", (clock() - start));
float* x = new float[6 * size];
cudaStatus = cudaMemcpy(x, temp, size * 6 * sizeof(float), cudaMemcpyDeviceToHost);
if (cudaStatus != cudaSuccess)
{
fprintf(stderr, "kernel failed!");
}
printf("%f %f %f %f", x[0], x[5], x[6], x[11]);
cudaFree(arr2);
cudaFree(temp);
while (1);
}
int ymain()
{
//cudaTestMemory();
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;
}
getchar();
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;
}
|
10,254 | #include <iostream>
#include <stdio.h>
#include<stdlib.h>
#include <math.h>
#include<valarray>
using namespace std;
int nsamples = 6000;
float float_rand( float min, float max )
{
return min + (rand() / (RAND_MAX/(max-min)) );
}
__global__ void solver(float* res, const int n, const float* rand_x, const float* rand_y)
{
int tid = threadIdx.x + blockIdx.x*blockDim.x;
float x,y;
float val = 0.0;
for (int i = 0; i < n; i++)
{
x = rand_x[i];
y = rand_y[i];
val += expf(-x*x-y*y);
}
__syncthreads();
res[tid] = val/n/(1.0/16.0);
}
int main()
{
int blocks = 300;
int threads = 300;
float h_res[threads*blocks];
float *d_res;
float *h_x = new float[nsamples];
float *h_y = new float[nsamples];
srand(time(NULL));
for (int i = 0; i < nsamples; i++)
{
h_x[i] = float_rand(-2, 2);
h_y[i] = float_rand(-2, 2);
}
float *d_x, *d_y;
cudaMalloc(&d_res, threads*blocks*sizeof(float));
cudaMalloc(&d_x, nsamples*sizeof(float));
cudaMalloc(&d_y, nsamples*sizeof(float));
cudaMemcpy(d_x, h_x, nsamples*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_y, h_y, nsamples*sizeof(float), cudaMemcpyHostToDevice);
solver<<<threads,blocks>>>(d_res, nsamples, d_x, d_y);
cudaMemcpy(h_res, d_res, threads*blocks*sizeof(float), cudaMemcpyDeviceToHost);
valarray<float> myvalarray(h_res,threads*blocks);
float result = myvalarray.sum()/float(threads*blocks);
cout<<"Result: "<<result<<endl;
cudaFree(d_res);
cudaFree(d_x);
cudaFree(d_y);
free(h_x);
free(h_y);
return 0;
}
|
10,255 | /*
* blockAndThread.cu
* includes setup funtion called from "driver" program
* also includes kernel function 'cu_fillArray()'
*/
#include <stdio.h>
#include <stdlib.h>
#define BLOCK_SIZE 8
// The __global__ directive identifies this function as a kernel
// Note: all kernels must be declared with return type void
__global__ void cu_fillArray (int *block_d, int *thread_d)
{
int x;
// Note: CUDA contains several built-in variables
// blockIdx.x returns the blockId in the x dimension
// threadIdx.x returns the threadId in the x dimension
x = blockIdx.x * BLOCK_SIZE + threadIdx.x;
block_d[x] = blockIdx.x;
thread_d[x] = threadIdx.x;
}
// This function is called from the host computer.
// It manages memory and calls the function that is executed on the GPU
extern "C" void fillArray (int *block, int *thread, int arraySize)
{
// block_d and thread_d are the GPU counterparts of the arrays that exists in host memory
int *block_d;
int *thread_d;
cudaError_t result;
// allocate space in the device
result = cudaMalloc ((void**) &block_d, sizeof(int) * arraySize);
if (result != cudaSuccess) {
fprintf(stderr, "cudaMalloc (block) failed.");
exit(1);
}
result = cudaMalloc ((void**) &thread_d, sizeof(int) * arraySize);
if (result != cudaSuccess) {
fprintf(stderr, "cudaMalloc (thread) failed.");
exit(1);
}
//copy the arrays from host to the device
result = cudaMemcpy (block_d, block, sizeof(int) * arraySize, cudaMemcpyHostToDevice);
if (result != cudaSuccess) {
fprintf(stderr, "cudaMemcpy host->dev (block) failed.");
exit(1);
}
result = cudaMemcpy (thread_d, thread, sizeof(int) * arraySize, cudaMemcpyHostToDevice);
if (result != cudaSuccess) {
fprintf(stderr, "cudaMemcpy host->dev (thread) failed.");
exit(1);
}
// set execution configuration
dim3 dimblock (BLOCK_SIZE);
dim3 dimgrid (arraySize/BLOCK_SIZE);
// actual computation: Call the kernel
cu_fillArray <<<dimgrid, dimblock>>> (block_d, thread_d);
// transfer results back to host
result = cudaMemcpy (block, block_d, sizeof(int) * arraySize, cudaMemcpyDeviceToHost);
if (result != cudaSuccess) {
fprintf(stderr, "cudaMemcpy host <- dev (block) failed.");
exit(1);
}
result = cudaMemcpy (thread, thread_d, sizeof(int) * arraySize, cudaMemcpyDeviceToHost);
if (result != cudaSuccess) {
fprintf(stderr, "cudaMemcpy host <- dev (thread) failed.");
exit(1);
}
// release the memory on the GPU
result = cudaFree (block_d);
if (result != cudaSuccess) {
fprintf(stderr, "cudaFree (block) failed.");
exit(1);
}
result = cudaFree (thread_d);
if (result != cudaSuccess) {
fprintf(stderr, "cudaFree (thread) failed.");
exit(1);
}
}
|
10,256 | #include <stdio.h>
#include <sys/time.h>
__global__
void bw(int n, float c, float *x, float *y){
int j = blockIdx.x;
if (j < n) y[j] = x[j] + c*y[j];
}
int main(void){
float *x, *y, *dev_x, *dev_y;
int N = 1<<10;
x = (float*)malloc(N*sizeof(float));
y = (float*)malloc(N*sizeof(float));
cudaMalloc(&dev_x, N*sizeof(float));
cudaMalloc(&dev_y, N*sizeof(float));
for (int j = 0; j < N; j++) {
x[j] = 4.0f;
y[j] = 1.0f;
}
cudaMemcpy(dev_x, x, N*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(dev_y, y, N*sizeof(float), cudaMemcpyHostToDevice);
cudaEvent_t start1, stop1;
cudaEventCreate(&start1);
cudaEventCreate(&stop1);
cudaEventRecord(start1);
bw<<<(N+447)/448,448>>>(N, 2.0f, dev_x, dev_y);
cudaEventRecord(stop1);
cudaEventSynchronize(stop1);
float time = 0;
cudaEventElapsedTime(&time, start1, stop1);
// N*4 number of bytes transferred r/w
// 3 = rx + ry + wy
printf("Bandwidth(GB/s): %f \n", N*4*3/time/1e6);
cudaFree(dev_x);
cudaFree(dev_y);
}
|
10,257 | #include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <sys/time.h>
// includes, kernels
#include "vector_dot_product_kernel.cu"
void run_test(unsigned int);
float compute_on_device(float *, float *,int);
extern "C" float compute_gold( float *, float *, unsigned int);
int
main( int argc, char** argv)
{
if(argc != 2){
printf("Usage: vector_dot_product <num elements> \n");
exit(0);
}
unsigned int num_elements = atoi(argv[1]);
run_test(num_elements);
return 0;
}
void
run_test(unsigned int num_elements)
{
// Obtain the vector length
unsigned int size = sizeof(float) * num_elements;
// Allocate memory on the CPU for the input vectors A and B
float *A = (float *)malloc(size);
float *B = (float *)malloc(size);
float gpu_result = 0.0f;
// Randomly generate input data. Initialize the input data to be floating point values between [-.5 , 5]
printf("Generating random vectors with values between [-.5, .5]. \n");
srand(time(NULL));
for(unsigned int i = 0; i < num_elements; i++){
A[i] = (float)rand()/(float)RAND_MAX - 0.5;
B[i] = (float)rand()/(float)RAND_MAX - 0.5;
}
printf("Generating dot product on the CPU. \n");
struct timeval start, stop;
gettimeofday(&start, NULL);
float reference = compute_gold(A, B, num_elements);
gettimeofday(&stop, NULL);
printf("Execution time CPU = %fs. \n", (float)(stop.tv_sec - start.tv_sec + (stop.tv_usec - start.tv_usec)/(float)1000000));
/* Edit this function to compute the result vector on the GPU.
The result should be placed in the gpu_result variable. */
gpu_result = compute_on_device(A, B, num_elements);
printf("Result on CPU: %f, result on GPU: %f. \n", reference, gpu_result);
printf("Epsilon: %f. \n", fabsf(reference - gpu_result));
// cleanup memory
free(A);
free(B);
return;
}
/* Edit this function to compute the dot product on the device using atomic intrinsics. */
float
compute_on_device(float *A_on_host, float *B_on_host, int num_elements)
{
float *A_on_device = NULL;
float *B_on_device = NULL;
float *result_on_device = NULL;
int *mutex_on_device = NULL;
cudaMalloc((void**)&A_on_device, num_elements * sizeof(float));
cudaMemcpy(A_on_device, A_on_host, num_elements * sizeof(float), cudaMemcpyHostToDevice);
cudaMalloc((void**)&B_on_device, num_elements * sizeof(float));
cudaMemcpy(B_on_device, B_on_host, num_elements * sizeof(float), cudaMemcpyHostToDevice);
/* Allocate space for the result on the GPU and initialize it. */
cudaMalloc((void**)&result_on_device, sizeof(float));
cudaMemset(result_on_device, 0.0f, sizeof(float));
/* Allocate space for the lock on the GPU and initialize it. */
cudaMalloc((void **)&mutex_on_device, sizeof(int));
cudaMemset(mutex_on_device, 0, sizeof(int));
// Set up the execution grid on the GPU
dim3 thread_block(THREAD_BLOCK_SIZE, 1, 1); // Set the number of threads in the thread block
dim3 grid(NUM_BLOCKS,1);
// Launch the kernel
struct timeval start, stop;
gettimeofday(&start, NULL);
vector_dot_product_kernel_atomics<<<grid, thread_block>>>(A_on_device, B_on_device, result_on_device, num_elements, mutex_on_device);
cudaThreadSynchronize();
gettimeofday(&stop, NULL);
printf("Execution time GPU = %fs. \n", (float)(stop.tv_sec - start.tv_sec + (stop.tv_usec - start.tv_usec)/(float)1000000));
float sum;
cudaMemcpy(&sum, result_on_device, sizeof(float), cudaMemcpyDeviceToHost);
// Free memory
cudaFree(A_on_device);
cudaFree(B_on_device);
cudaFree(result_on_device);
cudaFree(mutex_on_device);
return sum;
}
|
10,258 |
#include <cstdio>
#include <cuda_runtime.h>
#include <cufft.h>
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include "knn.cuh"
//#include "gpu_data.h"
#define gpu_errchk(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, "gpu_assert: %s %s %d\n",
cudaGetErrorString(code), file, line);
exit(code);
}
}
#define BW 1024
template<typename T> void cudaMemsetType(T *dev_ptr, T val, int n_vals)
{
thrust::device_ptr<T> thrust_dev_ptr(dev_ptr);
thrust::fill(thrust_dev_ptr, thrust_dev_ptr + n_vals, val);
}
// Uses reduction to quickly add things.
__global__ void correlationKernel(float* cij, float*sum, int total_size)
{
extern __shared__ float shmem[];
// atomically add the accumulated loss per block into the global accumulator
uint s_thread_index = threadIdx.x;
uint thread_index = blockIdx.x * blockDim.x + threadIdx.x;
while(thread_index < total_size)
{
shmem[s_thread_index] = cij[thread_index];
thread_index += blockDim.x * gridDim.x;
}
__syncthreads();
for(int stride = blockDim.x/2; stride > 0; stride /= 2)
{
if(s_thread_index < stride)
{
shmem[s_thread_index] += shmem[s_thread_index + stride];
}
__syncthreads();
}
if (threadIdx.x == 0){
atomicAdd(sum, shmem[0]);
}
}
// Called to get the sum from correlationKernel.
// cij is a lot larger than total_size, but we only want that much of it.
float correlationKernelSum(float* cij, int total_size)
{
// Inialize loss on the device to be zero
float sum, *d_sum;
gpu_errchk( cudaMalloc(&d_sum, sizeof(float)) );
cudaMemsetType<float>(d_sum, 0.0, 1);
float *gpu_cij;
gpu_errchk( cudaMalloc(&gpu_cij, total_size * sizeof(float)) );
gpu_errchk(cudaMemcpy(gpu_cij, cij, total_size * sizeof(float),
cudaMemcpyHostToDevice));
// Accumulate the total loss on the device by invoking a kernel
int n_blocks = std::min(65535, (total_size + BW - 1) / BW);
correlationKernel <<<n_blocks, BW, BW * sizeof(float)>>>(gpu_cij, d_sum, total_size);
gpu_errchk( cudaMemcpy(&sum, d_sum, sizeof(float), cudaMemcpyDeviceToHost) );
gpu_errchk( cudaFree(d_sum) );
gpu_errchk( cudaFree(gpu_cij) );
// Return the sum
return sum;
}
// This using threads to help us sort in parallel.
__global__
void mergeSortKernel( float *src, float*dst, float * followsrc, float * followdst, int section, int num_section, int total_size)
{
uint thread_index = blockIdx.x * blockDim.x + threadIdx.x;
int low = thread_index * section * num_section;
int mid, hi;
int slice = 0;
// Now we do stuff for each section.
while(slice < num_section && low < total_size)
{
mid = min(low + section/2, total_size);
hi = min(low + section, total_size);
merge(src, dst, followsrc, followdst,low, mid, hi);
low += section;
slice ++;
}
}
/*
* This function merges 2 lists [low to mid), [mid to hi) not in places.
*/
__device__
void merge(float *src, float *dst, float* followsrc, float* followdst, int low, int mid, int hi)
{
int a_counter = low;
int b_counter = mid;
for (int i = low; i < hi; i++) {
if (a_counter < mid && (b_counter >= hi || src[a_counter] > src[b_counter])) {
dst[i] = src[a_counter];
followdst[i] = followsrc[a_counter];
a_counter ++;
}
else
{
if (src[a_counter] == src[b_counter])
{
if (followsrc[a_counter] > followsrc[b_counter])
{
dst[i] = src[a_counter];
followdst[i] = followsrc[a_counter];
a_counter ++;
}
else
{
dst[i] = src[b_counter];
followdst[i] = followsrc[b_counter];
b_counter ++;
}
}
else
{
dst[i] = src[b_counter];
followdst[i] = followsrc[b_counter];
b_counter ++;
}
}
}
}
/*
* This function allocates memory for the device objects, and calls the merge kernel.
* Here, we start with small sections and sort them, and doubling the section size each time.
*/
void callMergeKernel(const unsigned int blocks, const unsigned int threadsPerBlock, float * cij, float * cijr, int total_size)
{
//Allocate GPU...
float *gpu_src;
gpu_errchk(cudaMalloc((void **) &gpu_src, total_size * sizeof(float)));
gpu_errchk(cudaMemcpy(gpu_src, cij, total_size * sizeof(float),
cudaMemcpyHostToDevice));
float *gpu_dst;
gpu_errchk(cudaMalloc((void **) &gpu_dst, total_size * sizeof(float)));
gpu_errchk(cudaMemset(gpu_dst, 0, total_size * sizeof(float)));
float *gpu_fsrc;
gpu_errchk(cudaMalloc((void **) &gpu_fsrc, total_size * sizeof(float)));
gpu_errchk(cudaMemcpy(gpu_fsrc, cijr, total_size * sizeof(float),
cudaMemcpyHostToDevice));
float *gpu_fdst;
gpu_errchk(cudaMalloc((void **) &gpu_fdst, total_size * sizeof(float)));
gpu_errchk(cudaMemset(gpu_fdst, 0, total_size * sizeof(float)));
int total_threads = blocks * threadsPerBlock;
for (int section = 2; section< total_size *2; section <<= 1) {
int num_section = total_size / ((total_threads) * section) + 1;
mergeSortKernel<<<blocks, threadsPerBlock>>>(gpu_src, gpu_dst, gpu_fsrc, gpu_fdst, section, num_section, total_size);
float *temp = gpu_dst;
gpu_dst = gpu_src;
gpu_src = temp;
temp = gpu_fdst;
gpu_fdst = gpu_fsrc;
gpu_fsrc = temp;
}
gpu_errchk(cudaMemcpy(cij, gpu_src, total_size * sizeof(float),
cudaMemcpyDeviceToHost));
gpu_errchk(cudaMemcpy(cijr, gpu_fsrc, total_size * sizeof(float),
cudaMemcpyDeviceToHost));
gpu_errchk( cudaFree(gpu_fsrc) );
gpu_errchk( cudaFree(gpu_src) );
gpu_errchk( cudaFree(gpu_dst) );
gpu_errchk( cudaFree(gpu_fdst) );
}
|
10,259 | #include "./BlockSync.cu"
#ifndef QUANTTENSOR
#define QUANTTENSOR
typedef struct Matrix{
int width;
int height;
float *elements;
} Matrix;
// A tensor will point to itself
// if rank > 2
typedef struct Tensor {
int width;
int height;
int size;
int layers;
int rank;
Tensor **tensor;
Matrix **matrix;
} Tensor;
__device__ void BuildWeightTensor(int width, int height, int layers, int size, float* elements, Tensor* tensor) {
InitBlockSync();
// Lets get our thread index
int grid_size = gridDim.x * gridDim.y;
int block_size = blockDim.x * blockDim.y;
int block_index = blockIdx.x + blockIdx.y * gridDim.x;
int local_index = threadIdx.x + threadIdx.y * blockDim.x;
int global_index = block_index * block_size + local_index;
int matrix_size = width * height;
// First we want to create tensor structures to hold
// our weight tensors for each layer. Avoid race condition
// in if block.
if (global_index == 0) {
tensor->width = width;
tensor->height = height;
tensor->size = size;
tensor->layers = layers;
// Rank 4 Tensor: tensors -> (tensors -> matrices)
// Rank 3 Tensor: tensors -> matrices
// Rank 2 Tensor: holds matrices
// Rank 1 Tensor: holds vectors
// Rank 0 Tensor: holds scalars
tensor->rank = 4;
tensor->tensor = (Tensor **)malloc(sizeof(Tensor *) * layers);
}
BlockSync();
// Avoid race condition by allowing only one thread
// to modify tensor metadata
if (global_index == 0) {
// Now we iterate through our tensor list and allocate memory
// for each tensor structure
for (int i = 0; i < layers; i ++) {
tensor->tensor[i] = (Tensor *)malloc(sizeof(Tensor));
tensor->tensor[i]->width = width;
tensor->tensor[i]->height = height;
tensor->tensor[i]->rank = 3;
tensor->tensor[i]->matrix = (Matrix **)malloc(sizeof(Matrix *) * matrix_size);
}
}
BlockSync();
// Matrix double pointers our allocated, we have alot of allocation
// operations to do now so we will parrallelize that now
Matrix* matrix;
int weight_index;
for (int i = 0; i < layers; i ++) {
Tensor* tensor_e = tensor->tensor[i];
for (int j = global_index; j < matrix_size; j += block_size * grid_size) {
// Allocate our matrix
tensor_e->matrix[j] = (Matrix *)malloc(sizeof(Matrix));
matrix = tensor_e->matrix[j];
matrix->width = width;
matrix->height = height;
matrix->elements = (float *)malloc(sizeof(float) * matrix_size);
for (int k = 0; k < matrix_size; k++) {
weight_index = k + j * matrix_size + i * matrix_size * matrix_size;
matrix->elements[k] = elements[weight_index];
}
}
}
BlockSync();
}
__device__ void clean() {
}
#endif |
10,260 | #include <stdio.h>
#include <stdlib.h>
__global__ void complement(int *A, int *B){
int i = blockIdx.x, j = threadIdx.x, m = gridDim.x, n = blockDim.x,k=1,temp,t=0,rev;
if(i!=0 && i!=m-1 && j!=0 && j!=n-1){
temp = A[i*n+j];
do{
t = t*10 + !(temp%2);
temp /= 2;
}while(temp>0);
do{
temp = t%10;
rev = rev*10 + temp;
t /= 10;
}while(t>0);
B[i*n+j] = rev;
}
else
B[i*n+j] = A[i*n+j];
}
int main(){
int *a,*t,m,n,i,j,*da,*dt;
printf("Enter m: ");
scanf("%d",&m);
printf("Enter n: ");
scanf("%d",&n);
int size = sizeof(int)*m*n;
a = (int *)malloc(size);
t = (int *)malloc(size);
printf("Enter the matrix:\n");
for(i=0;i<m*n;i++)
scanf("%d",&a[i]);
cudaMalloc((void **)&da,size);
cudaMalloc((void **)&dt,size);
cudaMemcpy(da,a,size,cudaMemcpyHostToDevice);
complement<<<m,n>>>(da,dt);
cudaMemcpy(t,dt,size,cudaMemcpyDeviceToHost);
printf("Result:\n");
for(i=0;i<m;i++){
for(j=0;j<n;j++)
printf("%d ",t[i*n+j]);
printf("\n");
}
cudaFree(da);
cudaFree(dt);
return 0;
}
|
10,261 | #include "includes.h"
__global__ void color_to_grey(uchar3 *input_image, uchar3 *output_image, int width, int height)
{
int col = threadIdx.x + blockIdx.x * blockDim.x;
int row = threadIdx.y + blockIdx.y * blockDim.y;
if(col < width && row < height)
{
int pos = row * width + col;
output_image[pos].x = static_cast<unsigned char>(input_image[pos].x * 0.2126f + input_image[pos].y * 0.7125f + input_image[pos].z * 0.0722f);
output_image[pos].y = static_cast<unsigned char>(input_image[pos].x * 0.2126f + input_image[pos].y * 0.7125f + input_image[pos].z * 0.0722f);
output_image[pos].z = static_cast<unsigned char>(input_image[pos].x * 0.2126f + input_image[pos].y * 0.7125f + input_image[pos].z * 0.0722f);
}
} |
10,262 | #include <cuda.h>
#include <stdio.h>
__global__ void printk(int *counter) {
do {
while (*counter % 2)
;
++*counter;
//__threadfence_system();
printf("\t%d\n", *counter);
} while (*counter < 10);
}
int main() {
int *counter;
cudaHostAlloc(&counter, sizeof(int), 0);
//cudaHostAlloc(&counter, sizeof(int), cudaHostAllocMapped);
printk <<<1, 1>>>(counter);
do {
printf("%d\n", *counter);
//fflush(stdout);
while (*counter % 2 == 0)
;
++*counter;
//__threadfence_system();
} while (*counter < 10);
cudaFreeHost(counter);
return 0;
}
|
10,263 | /*
Implementing map in CUDA. It squares each element in a matrix.
*/
#include <stdio.h>
#define BLOCK_WIDTH 2
#define MATRIX_SIZE 4
void print_matrix(unsigned int* array){
for(unsigned int i = 0; i < MATRIX_SIZE; i++){
for(unsigned int j = 0; j < MATRIX_SIZE; j++){
printf("%03d ", array[j + i * MATRIX_SIZE]);
}
printf("\n");
}
}
__device__ unsigned int square(unsigned int x){
return x*x;
}
__global__ void map(unsigned int* d_out, unsigned int* d_in){
unsigned int row = threadIdx.x + blockIdx.x * blockDim.x;
unsigned int col = threadIdx.y + blockIdx.y * blockDim.y;
if (row >= MATRIX_SIZE || col >= MATRIX_SIZE){
return;
}
unsigned int idx = col + row * MATRIX_SIZE;
d_out[idx] = square(d_in[idx]);
}
int main(){
const unsigned int NUM_ELEMENTS = MATRIX_SIZE * MATRIX_SIZE;
const unsigned int BYTES = NUM_ELEMENTS * sizeof(int);
unsigned int h_in[NUM_ELEMENTS];
for(unsigned int i = 0; i < NUM_ELEMENTS; i++){
h_in[i] = i;
}
unsigned int h_out[NUM_ELEMENTS];
unsigned int* d_in;
unsigned int* d_out;
cudaMalloc((void **) &d_in, BYTES);
cudaMalloc((void **) &d_out, BYTES);
const dim3 block_size(BLOCK_WIDTH, BLOCK_WIDTH, 1);
const unsigned int row_blocks = (unsigned int) (MATRIX_SIZE / BLOCK_WIDTH + 1);
const unsigned int col_blocks = (unsigned int) (MATRIX_SIZE / BLOCK_WIDTH + 1);
const dim3 grid_size(row_blocks, col_blocks, 1);
cudaMemcpy(d_in, h_in, BYTES, cudaMemcpyHostToDevice);
map<<<grid_size, block_size>>>(d_out, d_in);
cudaMemcpy(h_out, d_out, BYTES, cudaMemcpyDeviceToHost);
printf("Matrix before squaring: \n");
print_matrix(h_in);
printf("\n");
printf("Matrix after squaring: \n");
print_matrix(h_out);
cudaFree(d_in);
cudaFree(d_out);
return 0;
}
|
10,264 | #include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <cuda_runtime.h>
#include <sys/time.h>
#define CHECK(call) \
{ \
const cudaError_t error = call; \
if (error != cudaSuccess) \
{ \
printf("Error: %s:%d, ", __FILE__, __LINE__); \
printf("code:%d, reason: %s\n", error, cudaGetErrorString(error));\
exit(1); \
} \
}
double cpuSecond()
{
struct timeval tp;
gettimeofday(&tp, NULL);
return ((double)tp.tv_sec + (double)tp.tv_usec * 1.e-6);
}
void sumOnHost(float *A, float *B, float *C, const int N)
{
for (int idx = 0; idx < N; ++idx) {
C[idx] = A[idx] + B[idx];
}
}
void initData(float *ip, int size)
{
time_t t;
srand((unsigned int) time(&t));
for (int i = 0; i < size; ++i) {
ip[i] = (float)(rand() & 0xff) / 10.0f;
}
}
__global__ void sumOnDevice_single_block(float *A, float *B, float *C)
{
int id = threadIdx.x;
C[id] = A[id] + B[id];
//printf("blockDim.x: %d\t", blockDim.x);
//printf("blockDim.y: %d\t", blockDim.y);
//printf("blockDim.z: %d\n", blockDim.z);
}
__global__ void sumOnDevice_multi_block(float *A, float *B, float *C)
{
int id = blockIdx.x * blockDim.x + threadIdx.x;
C[id] = A[id] + B[id];
}
int main(void)
{
int nElem = 4096000;
size_t nByte = nElem * sizeof(float);
float *d_A, *d_B, *d_C;
float *h_A, *h_B, *h_C, *res;
h_A = (float *)malloc(nByte);
h_B = (float *)malloc(nByte);
h_C = (float *)malloc(nByte);
res = (float *)malloc(nByte);
initData(h_A, nElem);
initData(h_B, nElem);
CHECK(cudaMalloc((float**)&d_A, nByte));
CHECK(cudaMalloc((float**)&d_B, nByte));
CHECK(cudaMalloc((float**)&d_C, nByte));
CHECK(cudaMemcpy(d_A, h_A, nByte, cudaMemcpyHostToDevice));
CHECK(cudaMemcpy(d_B, h_B, nByte, cudaMemcpyHostToDevice));
double iStart = cpuSecond();
//sumOnDevice_single_block <<<1, nElem>>>(d_A, d_B, d_C);
//cudaDeviceReset();
int threadInBlock = 256; //in my case, greater than 1024 will failed; I use TX1;
dim3 block(threadInBlock);
dim3 grid ((nElem + block.x - 1) / block.x);
printf("block(%d, %d)\tgrid(%d, %d)\n", block.x, block.y, grid.x, grid.y);
sumOnDevice_multi_block <<<grid, block>>>(d_A, d_B, d_C);
cudaDeviceSynchronize();
double gpuTime = cpuSecond() - iStart;
iStart = cpuSecond();
sumOnHost(h_A, h_B, h_C, nElem);
double cpuTime = cpuSecond() - iStart;
CHECK(cudaMemcpy(res, d_C, nByte, cudaMemcpyDeviceToHost));
printf("%f\t%f\n", h_C[0], h_C[nElem - 1]);
printf("%f\t%f\n", res[0], res[nElem - 1]);
printf("GPU: %lf\n", gpuTime);
printf("CPU: %lf\n", cpuTime);
cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);
free(h_A);
free(h_B);
free(h_C);
free(res);
}
|
10,265 | #include "includes.h"
__global__ void run_reduction(int *con, int *blockCon,int* ActiveList, int nActiveBlock, int* blockSizes)
{
int list_idx = blockIdx.y*gridDim.x + blockIdx.x;
if(list_idx < nActiveBlock)
{
int block_idx = ActiveList[list_idx];
__shared__ int s_conv[REDUCTIONSHARESIZE];
uint base_addr = block_idx*blockDim.x*2; // *2 because there are only half block size number of thread
uint tx = threadIdx.x;
s_conv[tx] = con[base_addr + tx];
s_conv[tx + blockDim.x] = con[base_addr + tx + blockDim.x];
__syncthreads();
for(uint i=blockDim.x; i>0; i/=2)
{
if(tx < i)
{
bool b1, b2;
b1 = s_conv[tx];
b2 = s_conv[tx+i];
s_conv[tx] = (b1 && b2) ? 1 : 0 ;
}
__syncthreads();
}
if(tx == 0)
{
blockCon[block_idx] = s_conv[0]; // active list is negation of tile convergence (active = not converged)
}
}
} |
10,266 | #include<iostream>
#include<cuda.h>
using namespace std;
int main(){
cudaDeviceProp prop;
int count;
cudaGetDeviceCount(&count);
for(int i=0;i<count;i++){
cudaGetDeviceProperties(&prop,i);
cout<<"--- General Information for device "<<i<<endl;
cout<<"Name: "<<prop.name<<endl;
cout<<"Compute capability: "<<prop.major<<", "<<prop.minor<<endl;
cout<<"Clock rate: "<<prop.clockRate<<endl;
cout<<"Device copy overlap: "<<prop.deviceOverlap<<endl;
cout<<"Total global memory: "<<prop.totalGlobalMem<<endl;
cout<<"Total const memory: "<<prop.totalConstMem<<endl;
return 0;
}
} |
10,267 | #include <stdio.h>
#include <cuda_runtime.h>
__device__ char xx;
__device__ char xxx;
__global__ void cuCopyTest( char *s1, char *s2)
{
char out;
char * dest;
char * src;
int n;
dest = (s1 == NULL) ? &xx : &xxx;
src = s1;
n = 1;
while(n-- > 0)
*dest++ = *src++;
dest = &out;
src = s2;
n = 1;
while(n-- > 0)
*dest++ = *src++;
}
|
10,268 |
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
void multiplyWithCuda(long *c, const long *a, const long *b, unsigned int size);
void multiplyWithCudaKaratsuba(long *c, const long *a, const long *b, unsigned int size);
__device__ void multiplyKernelKaratsubaRec(long *z, const long *x, const long *y, unsigned int size)
{
const long *a, *b, *c, *d;
long *ab, *ac;
long *bd, *cd;
long *adbc;
if (size <= 1)
{
z[0] = x[0] * y[0];
}
else
{
int half = (int)size / 2;
ab = (long*)malloc(half * sizeof(long));
ac = (long*)malloc(half * sizeof(long));
cd = (long*)malloc(half * sizeof(long));
bd = (long*)malloc(half * sizeof(long));
adbc = (long*)malloc(half * sizeof(long));
a = x;
b = x + half;
c = y;
d = y + half;
multiplyKernelKaratsubaRec(ac, a, c, half);
multiplyKernelKaratsubaRec(bd, b, d, size - half);
int i = 0;
for (i = 0; i < half; i++)
{
ab[i] = a[i] + b[i];
cd[i] = c[i] + d[i];
}
multiplyKernelKaratsubaRec(adbc, ab, cd, half);
for (i = 0; i < half; i++)
{
z[i] = adbc[i] - ac[i] - bd[i];
}
}
}
__global__ void multiplyKernelKaratsuba(long *z, const long *x, const long *y, unsigned int size)
{
multiplyKernelKaratsubaRec(z, x, y, size);
}
__global__ void multiplyKernel(long *c, const long *a, const long *b, unsigned int size)
{
int i = threadIdx.x;
c[i] = 0;
for (auto x = 0; x < size; x++)
{
for (auto y = 0; y < size; y++)
{
if (x + y == i)
{
c[i] += a[x] * b[y];
}
}
}
}
int main()
{
srand(time(nullptr));
const auto arraySize = 512;
long a[arraySize];
long b[arraySize];
long c[2 * arraySize];
for (auto i = 0; i < arraySize; i++)
{
a[i] = rand() % 100;
b[i] = rand() % 100;
c[i] = c[arraySize + i] = 0;
}
// Multiply polynomials in parallel.
time_t timeStart;
time_t timeEnd;
time(&timeStart);
for (auto i = 0; i < 100; i++)
multiplyWithCuda(c, a, b, arraySize);
time(&timeEnd);
printf("time taken (normal) : %lld (%lld : %lld) \n", timeEnd - timeStart, timeStart, timeEnd);
time(&timeStart);
for (auto i = 0; i < 100; i++)
multiplyWithCudaKaratsuba(c, a, b, arraySize);
time(&timeEnd);
printf("time taken (karatsuba) : %lld (%lld : %lld) \n", timeEnd - timeStart, timeStart, timeEnd);
// for (auto i = 0; i < arraySize; i++)
// {
// printf("%d ", a[i]);
// }
// printf("\n");
//
// for (auto i = 0; i < arraySize; i++)
// {
// printf("%d ", b[i]);
// }
// printf("\n");
//
// for (auto i = 0; i < 2 * arraySize; i++)
// {
// printf("%d ", c[i]);
// }
// printf("\n");
cudaDeviceReset();
return 0;
}
void multiplyWithCudaKaratsuba(long *c, const long *a, const long *b, unsigned int size)
{
long *dev_a = nullptr;
long *dev_b = nullptr;
long *dev_c = nullptr;
cudaSetDevice(0);
cudaMalloc(&dev_c, 2 * size * sizeof(long));
cudaMalloc(&dev_a, size * sizeof(long));
cudaMalloc(&dev_b, size * sizeof(long));
cudaMemcpy(dev_a, a, size * sizeof(long), cudaMemcpyHostToDevice);
cudaMemcpy(dev_b, b, size * sizeof(long), cudaMemcpyHostToDevice);
int thread_num = 2 * size;
multiplyKernelKaratsuba <<<1, thread_num >>> (dev_c, dev_a, dev_b, size);
cudaDeviceSynchronize();
cudaMemcpy(c, dev_c, 2 * size * sizeof(long), cudaMemcpyDeviceToHost);
cudaFree(dev_c);
cudaFree(dev_a);
cudaFree(dev_b);
}
void multiplyWithCuda(long *c, const long *a, const long *b, unsigned int size)
{
long *dev_a = nullptr;
long *dev_b = nullptr;
long *dev_c = nullptr;
cudaSetDevice(0);
cudaMalloc(&dev_c, 2 * size * sizeof(long));
cudaMalloc(&dev_a, size * sizeof(long));
cudaMalloc(&dev_b, size * sizeof(long));
cudaMemcpy(dev_a, a, size * sizeof(long), cudaMemcpyHostToDevice);
cudaMemcpy(dev_b, b, size * sizeof(long), cudaMemcpyHostToDevice);
int thread_num = 2 * size;
multiplyKernel<<<1, thread_num>>>(dev_c, dev_a, dev_b, size);
cudaDeviceSynchronize();
cudaMemcpy(c, dev_c, 2 * size * sizeof(long), cudaMemcpyDeviceToHost);
cudaFree(dev_c);
cudaFree(dev_a);
cudaFree(dev_b);
}
|
10,269 | #include <iostream>
#include <utility>
#include <algorithm>
#include <sys/time.h>
using namespace std;
const int INF = 1e9 + 7;
bool cmp(pair<int, int> a, pair<int, int> b) {
if(a.first == b.first) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
__global__
void reduceMin(int n ,pair<int, int> *min_edge, bool *visited, int* minval, int* idxmin)
{
int index = blockIdx.x * blockDim.x + threadIdx.x;
int stride = blockDim.x * gridDim.x;
int localmin = INF;
int localidxmin = -1;
for(int j = index; j < n; j += stride) {
if(visited[j] == 0 && (localidxmin == -1 || min_edge[j].first < min_edge[localidxmin].first)) {
localidxmin = j;
localmin = min_edge[j].first;
}
}
atomicMin(minval, localmin);
__syncthreads();
if(*minval == localmin) {
*idxmin = localidxmin;
}
}
int main(){
int n;
cin >> n;
int *adj, *idxmin, *minval;
pair<int, int> *min_edge, *result;
bool *visited;
cudaMallocManaged(&adj, n * n * sizeof(int));
cudaMallocManaged(&idxmin, sizeof(int));
cudaMallocManaged(&minval, sizeof(int));
cudaMallocManaged(&min_edge, n * sizeof(pair<int, int>));
cudaMallocManaged(&result, n * sizeof(pair<int, int>));
cudaMallocManaged(&visited, n * sizeof(bool));
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
cin >> adj[i * n + j];
// akses tidak bisa [][]. harus [], maka diflatten
if(adj[i * n + j] == -1) adj[i * n + j] = INF;
}
visited[i] = 0;
// first: weight, second: terhubung sama apa
min_edge[i].first = INF;
min_edge[i].second = -1;
}
int total_weight = 0;
min_edge[0].first = 0;
int cur = 0;
struct timeval stop, start;
gettimeofday(&start, NULL);
for(int i = 0; i < n; i++) {
int blockSize = 256;
int numBlocks = (n + blockSize - 1) / blockSize;
*idxmin = -1;
*minval = INF;
reduceMin<<<numBlocks, blockSize>>>(n, min_edge, visited, minval, idxmin);
cudaDeviceSynchronize();
int t = *idxmin;
visited[t] = 1;
total_weight += min_edge[t].first;
if(min_edge[t].second != -1) {
result[cur].first = min(t, min_edge[t].second);
result[cur].second = max(t, min_edge[t].second);
cur++;
}
//cout << *idxmin << " this is " << *minval << '\n';
for(int to = 0; to < n; to++) {
if(adj[t * n + to] < min_edge[to].first) {
min_edge[to].first = adj[t * n + to];
min_edge[to].second = t;
}
//cout << min_edge[to].first << " - " << min_edge[to].second << '\n';
}
}
gettimeofday(&stop, NULL);
sort(result, result + cur, cmp);
cout << total_weight << '\n';
for(int i = 0; i < cur; i++) {
cout << result[i].first << '-' << result[i].second << '\n';
}
cout << "Waktu Eksekusi: " << (stop.tv_sec - start.tv_sec) * 1000 + (stop.tv_usec - start.tv_usec) / 1000 << " ms\n";
cudaFree(adj);
cudaFree(idxmin);
cudaFree(minval);
cudaFree(min_edge);
cudaFree(result);
cudaFree(visited);
return 0;
} |
10,270 | extern "C" __global__ void nvrtc_add_kernel(const float* input, float* output, int n, float val) {
int i = blockIdx.x*blockDim.x + threadIdx.x;
if (i < n) {
output[i] = input[i]+ val;
}
} |
10,271 | /////////////////////////////////////////////////////////////////////////
//
// 備考:このコードでは二次元行列同士の内積を行い実行時間を観測する。
//
/////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
////////////////////////
// ↓行列構造体定義
////////////////////////
typedef struct matrix{
int col;
int row;
double* element;
}Matrix;
//////////////////////////////////
// ↓内積を行うカーネル関数
//////////////////////////////////
__global__
void gpu_dot(const double* x,const double* w,double* out,const int* x_row,const int* w_row, const int* w_col){
int i,j,k;
double sum = 0;
//変数iには現在実行中のスレッドの固有の番号(y軸)が入る(スレッド数は結果保存用行列構造体の行数個ある)
//変数jには現在実行中のスレッドの固有の番号(x軸)が入る(スレッド数は結果保存用行列構造体の列数個ある)
i = blockIdx.y * blockDim.y + threadIdx.y;
j = blockIdx.x * blockDim.x + threadIdx.x;
for(k=0; k<(*w_col); k++){
sum += x[i*(*x_row)+k] * w[k*(*w_row)+j];
}
out[i*(*w_row)+j] = sum;
}
////////////////////////////////////////////////////
// ↓行列構造体を操作する関数のプロトタイプ宣言
////////////////////////////////////////////////////
//↓コンストラクタ
void Matrix_constructor(Matrix* self,const int col,const int row);
//↓行列の要素に要素番号代入
void Matrix_init(Matrix* self);
//↓行列をゼロクリア
void Matrix_zeros(Matrix* self);
//↓行列の中身をすべて表示
void Matrix_print(Matrix* self);
//行列構造体内の要素開放
void Matrix_free(Matrix* self);
///////////////////////
// ↓メイン関数
///////////////////////
int main(){
//↓タイマー用変数宣言
time_t start,stop;
//↓行列構造体宣言
Matrix x;
Matrix w;
Matrix out;//←計算結果保存用
//↓行列構造体のコンストラクタ
Matrix_constructor(&x,2000,3000);
Matrix_constructor(&w,3000,5000);
Matrix_constructor(&out,2000,5000);
//↓入力用の行列に数値代入
Matrix_init(&x);
Matrix_init(&w);
//↓出力保存用行列を0クリア
Matrix_zeros(&out);
//↓カーネル関数の引数に使う変数宣言(配列として使う)
double* gpu_x;
double* gpu_w;
double* gpu_out;
//↓カーネル関数の引数に使う変数宣言(定数として使う)
int* x_row;
int* w_row;
int* w_col;
//↓cudaMallocでかかる時間測定開始
start = clock();
//↓カーネルの引数に使う配列の動的確保
cudaMalloc(&gpu_x,sizeof(double)*x.col*x.row);
cudaMalloc(&gpu_w,sizeof(double)*w.col*w.row);
cudaMalloc(&gpu_out,sizeof(double)*out.col*out.row);
//↓カーネルの引数に使う定数の動的確保
cudaMalloc(&x_row,sizeof(int));
cudaMalloc(&w_row,sizeof(int));
cudaMalloc(&w_col,sizeof(int));
//↓cudaMallocでかかる時間測定終了
stop = clock();
//↓cudaMallocでかかる時間表示
printf("cudaMalloc:%lf秒\n",(double)(stop-start)/CLOCKS_PER_SEC);
//↓cudaMemcpyでかかる時間測定開始
start = clock();
//↓計算で使う行列の中身をカーネルの引数で使う変数へコピー
cudaMemcpy(gpu_x,x.element,sizeof(double)*x.col*x.row,cudaMemcpyHostToDevice);
cudaMemcpy(gpu_w,w.element,sizeof(double)*w.col*w.row,cudaMemcpyHostToDevice);
//↓計算で使う定数の中身をカーネルの引数で使う変数へコピー
cudaMemcpy(x_row,&(x.row),sizeof(int),cudaMemcpyHostToDevice);
cudaMemcpy(w_row,&(w.row),sizeof(int),cudaMemcpyHostToDevice);
cudaMemcpy(w_col,&(w.col),sizeof(int),cudaMemcpyHostToDevice);
//↓cudaMemcpyでかかる時間測定終了
stop = clock();
//↓cudaMemcpyでかかる時間表示
printf("cudaMemcpy(Host_to_Device):%lf秒\n",(double)(stop-start)/CLOCKS_PER_SEC);
//↓内積計算でかかる時間測定開始
start = clock();
//↓内積計算実行
gpu_dot<<<dim3(out.row,out.col,1),dim3(1,1,1)>>>(gpu_x,gpu_w,gpu_out,x_row,w_row,w_col);
cudaDeviceSynchronize();
//↓内積計算でかかる時間測定終了
stop = clock();
//↓内積計算でかかる時間表示
printf("内積計算:%lf秒\n",(double)(stop-start)/CLOCKS_PER_SEC);
//↓カーネル用変数からホスト用変数に内容をコピーするのにかかる時間測定開始
start = clock();
//↓カーネル用変数からホスト用変数に内容をコピー
cudaMemcpy(out.element,gpu_out,sizeof(double)*out.col*out.row,cudaMemcpyDeviceToHost);
//↓カーネル用変数からホスト用変数に内容をコピーするのにかかる時間測定終了
stop = clock();
//↓カーネル用変数からホスト用変数に内容をコピーするのにかかる時間表示
printf("cudaMemcpy(Devise_to_Host):%lf秒\n",(double)(stop-start)/CLOCKS_PER_SEC);
//↓ホスト側デバイス側共に動的確保した領域開放
cudaFree(gpu_x);
cudaFree(gpu_w);
cudaFree(gpu_out);
cudaFree(x_row);
cudaFree(w_row);
cudaFree(w_col);
Matrix_free(&x);
Matrix_free(&w);
Matrix_free(&out);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////
// ↓ここから行列構造体を操作する関数の実装(関数の解説は上記のプロトタイプ宣言部分に記載)
///////////////////////////////////////////////////////////////////////////////////////////////
void Matrix_constructor(Matrix* self,const int col,const int row){
self->col = col;
self->row = row;
self->element = (double*)malloc(sizeof(double)*col*row);
}
void Matrix_init(Matrix* self){
for(int i=0;i<self->col;i++){
for(int j=0;j<self->row;j++){
self->element[i*self->row+j] = i*self->row+j;
}
}
}
void Matrix_zeros(Matrix* self){
for(int i=0;i<self->col;i++){
for(int j=0;j<self->row;j++){
self->element[i*self->row+j] = 0;
}
}
}
void Matrix_print(Matrix* self){
for(int i=0;i<self->col;i++){
for(int j=0;j<self->row;j++){
printf("[%lf]",self->element[i*self->row+j]);
}
printf("\n");
}
}
void Matrix_free(Matrix* self){
free(self->element);
self->element = NULL;
}
|
10,272 |
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include "string.h"
//#include "cudaSobel.cu"
//#include <helper_image.h>
#define DEFAULT_THRESHOLD 4000
#define BLOCKSIZE 32
#define DEFAULT_FILENAME "BWstop-sign.ppm"
__global__ void d_sobel1(int *result, unsigned int *pic, int xsize, int ysize, int thresh)
{
int sum1, sum2, magnitude;
int i = threadIdx.x + blockIdx.x * blockDim.x;
int j = threadIdx.y + blockIdx.y * blockDim.y;
if (i>0 && j>0 && i<479 &&j<383)
{
//if (j > 470)
int index = i * xsize + j;
sum1 = pic[ xsize * (i-1) + j+1 ] - pic[ xsize*(i-1) + j-1 ]
+ 2 * pic[ xsize * (i) + j+1 ] - 2 * pic[ xsize*(i) + j-1 ]
+ pic[ xsize * (i+1) + j+1 ] - pic[ xsize*(i+1) + j-1 ];
sum2 = pic[ xsize * (i-1) + j-1 ] + 2 * pic[ xsize * (i-1) + j ] + pic[ xsize * (i-1) + j+1 ]
- pic[xsize * (i+1) + j-1 ] - 2 * pic[ xsize * (i+1) + j ] - pic[ xsize * (i+1) + j+1 ];
magnitude = sum1*sum1 + sum2*sum2;
if (magnitude > thresh)
result[index] = 255;
else
result[index] = 0;
// if (i >=383 && j >=479 )
}
}
// gpu version 1 of the parallel sobel code
void sobel1(int *h_result, unsigned int *h_pic, int xsize, int ysize, int thresh)
{
int *d_result;
unsigned int *d_pic;
// space for device result and pic
int resultSize = xsize * ysize * 3 * sizeof(int);
int picSize = xsize * ysize * sizeof(int);
// allocate device space
cudaMalloc( (void**)&d_result, resultSize);
if( !d_result) {
exit(-1);
}
cudaMalloc( (void**)&d_pic, picSize);
if( !d_pic) {
exit(-1);
}
// copy from the host to device
cudaMemcpy(d_result, h_result, resultSize, cudaMemcpyHostToDevice);
cudaMemcpy(d_pic, h_pic, picSize, cudaMemcpyHostToDevice);
// launch the kernel
dim3 threadsPerBlock(BLOCKSIZE, BLOCKSIZE);
dim3 numBlocks(ceil((float)ysize/(float)threadsPerBlock.x), ceil((float)xsize/(float)threadsPerBlock.y));
// setup event recording
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
d_sobel1 <<< numBlocks, threadsPerBlock >>> (d_result, d_pic, xsize, ysize, thresh);
// finish recording time
cudaEventSynchronize(stop);
float elapsedTime;
cudaEventElapsedTime(&elapsedTime, start, stop);
cudaEventDestroy(start);
cudaEventDestroy(stop);
//d_sobel1 <<< ceil((float)(xsize+ysize-2)/(float)BLOCKSIZE), BLOCKSIZE >>> (d_result, d_pic, xsize);
// copy the result back to the host
cudaMemcpy(h_result, d_result, resultSize, cudaMemcpyDeviceToHost);
cudaMemcpy(h_pic, d_pic, picSize, cudaMemcpyDeviceToHost);
// free device space
cudaFree(d_result);
cudaFree(d_pic);
}
__global__ void d_sobel2(int *result, unsigned int *pic, int width, int height, int thresh)
{
int sum1, sum2, magnitude;
int x = threadIdx.x + blockIdx.x * blockDim.x;
int y = threadIdx.y + blockIdx.y * blockDim.y;
int index = x * width +y ;
//if (x>0 && y>0 && x<height -1 &&y<width -1)
__shared__ unsigned int pic_s[BLOCKSIZE+2][BLOCKSIZE+2];
int threadX = threadIdx.x;
int threadY = threadIdx.y;
pic_s[threadX+1][threadY+1] = pic[index];
// top left corner
if(threadX <1 && threadY <1)
pic_s[threadX][threadY] = pic[(x-1)*width + y-1];
// top right corner
if(threadX <1 && threadY > BLOCKSIZE -2)
pic_s[threadX][threadY+2] = pic[(x-1)*width + y+1];
// bottom left corner
if(threadX > BLOCKSIZE -2 && threadY <1)
pic_s[threadX+2][threadY] = pic[(x+1)*width + y-1];
// bottom right corner
if(threadX > BLOCKSIZE -2 && threadY > BLOCKSIZE -2)
pic_s[threadX+2][threadY+2] = pic[(x+1)*width + y+1];
// top edge
if (threadX < 1)
pic_s[threadX][threadY+1] = pic[(x-1)*width + y];
// bottom edge
if (threadX > BLOCKSIZE -2)
pic_s[threadX+2][threadY+1] = pic[(x+1)*width + y];
// left edge
if (threadY < 1)
pic_s[threadX+1][threadY] = pic[(x)*width + y-1];
// right edge
if (threadY > BLOCKSIZE -2)
pic_s[threadX+1][threadY+2] = pic[(x)*width + y+1];
//__syncthreads();
sum1 = pic_s[threadX][threadY+2] - pic_s[threadX][threadY]
+ 2 * pic_s[threadX+1][threadY+2] - 2 * pic_s[threadX+1][threadY]
+ pic_s[threadX+2][threadY+2] - pic_s[threadX+2][threadY];
sum2 = pic_s[threadX][threadY] + 2 * pic_s[threadX][threadY+1] + pic_s[threadX][threadY+2]
- pic_s[threadX+2][threadY] - 2 * pic_s[threadX+2][threadY+1] - pic_s[threadX+2][threadY+2];
magnitude = sum1*sum1 + sum2*sum2;
//__syncthreads();
if (magnitude > thresh)
result[index] = 255;
else
result[index] = 0;
if (x ==0 || y ==0 || x==height-1 || y == width-1)
result[index] = 0;
}
// gpu version 2 of the parallel sobel code
void sobel2(int *h_result, unsigned int *h_pic, int width, int height, int thresh)
{
int *d_result;
unsigned int *d_pic;
// space for device result and pic
int resultSize = width * height * 3 * sizeof(int);
int picSize = width * height * sizeof(int);
// allocate device space
cudaMalloc( (void**)&d_result, resultSize);
if( !d_result) {
exit(-1);
}
cudaMalloc( (void**)&d_pic, picSize);
if( !d_pic) {
exit(-1);
}
// copy from the host to device
cudaMemcpy(d_result, h_result, resultSize, cudaMemcpyHostToDevice);
cudaMemcpy(d_pic, h_pic, picSize, cudaMemcpyHostToDevice);
// launch the kernel
dim3 threadsPerBlock(BLOCKSIZE, BLOCKSIZE);
dim3 numBlocks(ceil((float)height/(float)threadsPerBlock.x), ceil((float)width/(float)threadsPerBlock.y));
// setup event recording
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
d_sobel2 <<< numBlocks, threadsPerBlock >>> (d_result, d_pic, width, height, thresh);
// finish recording time
cudaEventSynchronize(stop);
float elapsedTime;
cudaEventElapsedTime(&elapsedTime, start, stop);
cudaEventDestroy(start);
cudaEventDestroy(stop);
// copy the result back to the host
cudaMemcpy(h_result, d_result, resultSize, cudaMemcpyDeviceToHost);
cudaMemcpy(h_pic, d_pic, picSize, cudaMemcpyDeviceToHost);
// free device space
cudaFree(d_result);
cudaFree(d_pic);
}
unsigned int *read_ppm( char *filename, int * xsize, int * ysize, int *maxval ){
if ( !filename || filename[0] == '\0') {
fprintf(stderr, "read_ppm but no file name\n");
return NULL; // fail
}
FILE *fp;
fprintf(stderr, "read_ppm( %s )\n", filename);
fp = fopen( filename, "rb");
if (!fp)
{
fprintf(stderr, "read_ppm() ERROR file '%s' cannot be opened for reading\n", filename);
return NULL; // fail
}
char chars[1024];
//int num = read(fd, chars, 1000);
int num = fread(chars, sizeof(char), 1000, fp);
if (chars[0] != 'P' || chars[1] != '6')
{
fprintf(stderr, "Texture::Texture() ERROR file '%s' does not start with \"P6\" I am expecting a binary PPM file\n", filename);
return NULL;
}
unsigned int width, height, maxvalue;
char *ptr = chars+3; // P 6 newline
if (*ptr == '#') // comment line!
{
ptr = 1 + strstr(ptr, "\n");
}
num = sscanf(ptr, "%d\n%d\n%d", &width, &height, &maxvalue);
fprintf(stderr, "read %d things width %d height %d maxval %d\n", num, width, height, maxvalue);
*xsize = width;
*ysize = height;
*maxval = maxvalue;
unsigned int *pic = (unsigned int *)malloc( width * height * sizeof(unsigned int));
if (!pic) {
fprintf(stderr, "read_ppm() unable to allocate %d x %d unsigned ints for the picture\n", width, height);
return NULL; // fail but return
}
// allocate buffer to read the rest of the file into
int bufsize = 3 * width * height * sizeof(unsigned char);
if ((*maxval) > 255) bufsize *= 2;
unsigned char *buf = (unsigned char *)malloc( bufsize );
if (!buf) {
fprintf(stderr, "read_ppm() unable to allocate %d bytes of read buffer\n", bufsize);
return NULL; // fail but return
}
// TODO really read
char duh[80];
char *line = chars;
// find the start of the pixel data. no doubt stupid
sprintf(duh, "%d\0", *xsize);
line = strstr(line, duh);
//fprintf(stderr, "%s found at offset %d\n", duh, line-chars);
line += strlen(duh) + 1;
sprintf(duh, "%d\0", *ysize);
line = strstr(line, duh);
//fprintf(stderr, "%s found at offset %d\n", duh, line-chars);
line += strlen(duh) + 1;
sprintf(duh, "%d\0", *maxval);
line = strstr(line, duh);
fprintf(stderr, "%s found at offset %d\n", duh, line - chars);
line += strlen(duh) + 1;
long offset = line - chars;
//lseek(fd, offset, SEEK_SET); // move to the correct offset
fseek(fp, offset, SEEK_SET); // move to the correct offset
//long numread = read(fd, buf, bufsize);
long numread = fread(buf, sizeof(char), bufsize, fp);
fprintf(stderr, "Texture %s read %ld of %ld bytes\n", filename, numread, bufsize);
fclose(fp);
int pixels = (*xsize) * (*ysize);
for (int i=0; i<pixels; i++) pic[i] = (int) buf[3*i]; // red channel
return pic; // success
}
void write_ppm( char *filename, int xsize, int ysize, int maxval, int *pic)
{
FILE *fp;
int x,y;
fp = fopen(filename, "w");
if (!fp)
{
fprintf(stderr, "FAILED TO OPEN FILE '%s' for writing\n");
exit(-1);
}
fprintf(fp, "P6\n");
fprintf(fp,"%d %d\n%d\n", xsize, ysize, maxval);
int numpix = xsize * ysize;
for (int i=0; i<numpix; i++) {
unsigned char uc = (unsigned char) pic[i];
fprintf(fp, "%c%c%c", uc, uc, uc);
}
fclose(fp);
}
int* standardSobel(int *result, unsigned int *pic, int xsize, int ysize, int thresh)
{
int i, j, magnitude, sum1, sum2;
int *out = result;
for (int col=0; col<ysize; col++) {
for (int row=0; row<xsize; row++) {
*out++ = 0;
}
}
for (i = 1; i < ysize - 1; i++) {
for (j = 1; j < xsize -1; j++) {
int offset = i*xsize + j;
sum1 = pic[ xsize * (i-1) + j+1 ] - pic[ xsize*(i-1) + j-1 ]
+ 2 * pic[ xsize * (i) + j+1 ] - 2 * pic[ xsize*(i) + j-1 ]
+ pic[ xsize * (i+1) + j+1 ] - pic[ xsize*(i+1) + j-1 ];
sum2 = pic[ xsize * (i-1) + j-1 ] + 2 * pic[ xsize * (i-1) + j ] + pic[ xsize * (i-1) + j+1 ]
- pic[xsize * (i+1) + j-1 ] - 2 * pic[ xsize * (i+1) + j ] - pic[ xsize * (i+1) + j+1 ];
magnitude = sum1*sum1 + sum2*sum2;
if (magnitude > thresh)
result[offset] = 255;
else
result[offset] = 0;
}
}
return result;
}
int compareNumPixels(int *result1, int *result2, int xsize, int ysize)
{
int numPixels = xsize * ysize;
for (int i = 0; i<numPixels; i++)
{
if((unsigned char)result1[i] != (unsigned char)result2[i])
{
printf("pixel at i= %d, not equal 1 = %d, 2= %d, \n", i, result1[i], result2[i]);
return -1;
}
}
return 1;
}
int compare(int *result1, int * result2, int xsize, int ysize)
{
printf("starting compare \n");
for (int i = 0; i<ysize; i ++)
{
for (int j = 0; j<xsize; j++)
{
int index = i*xsize+j;
if ((unsigned char)result1[index] != (unsigned char)result2[index])
{
printf("xsize = %d, ysize = %d, pixel at I= %d, j= %d, index %d, not equal 1 = %d, 2= %d, \n", xsize, ysize, i, j, index, result1[index], result2[index]);
compareNumPixels(result1, result2, xsize, ysize);
exit(-1);
}
}
}
return 1;
}
int main( int argc, char **argv )
{
int thresh = DEFAULT_THRESHOLD;
char *filename;
filename = strdup( DEFAULT_FILENAME);
if (argc > 1) {
if (argc == 3) { // filename AND threshold
filename = strdup( argv[1]);
thresh = atoi( argv[2] );
}
if (argc == 2) { // default file but specified threshhold
thresh = atoi( argv[1] );
}
fprintf(stderr, "file %s threshold %d\n", filename, thresh);
}
int xsize = 200;
int ysize = 200;
int maxval;
unsigned int *pic = read_ppm( filename, &xsize, &ysize, &maxval );
int numbytes = xsize * ysize * 3 * sizeof( int );
//printf("numbytes = %d \n", numbytes);
int *result = (int *) malloc( numbytes );
int *gpu1Result = (int *) malloc(numbytes);
int *gpu2Result = (int *) malloc(numbytes);
if (!result) {
fprintf(stderr, "sobel() unable to malloc %d bytes\n", numbytes);
exit(-1); // fail
}
if(!gpu1Result) {
fprintf(stderr, "gpu1result unable to malloc %d bytes \n", numbytes);
exit(-1); // failed again
}
if(!gpu2Result) {
fprintf(stderr, "gpu2result unable to malloc %d bytes \n", numbytes);
exit(-1); // failed again
}
printf("single threaded sobel\n");
// non threaded sobel
//setup some timing
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
result = standardSobel(result, pic, xsize, ysize, thresh);
// finish some timing
cudaEventSynchronize(stop);
float elapsedTime;
cudaEventElapsedTime(&elapsedTime, start, stop);
cudaEventDestroy(start);
cudaEventDestroy(stop);
printf("Single threaded elapsed time, kernel only = %f \n", elapsedTime);
write_ppm( "result.ppm", xsize, ysize, 255, result);
printf("gpu1 \n");
sobel1(gpu1Result, pic, xsize, ysize, thresh);
write_ppm( "gpu1Result.ppm", xsize, ysize, 255, gpu1Result);
printf("gpu2 \n");
sobel2(gpu2Result, pic, xsize, ysize, thresh);
write_ppm( "gpu2Result.ppm", xsize, ysize, 255, gpu2Result);
fprintf(stderr, "sobel done\n");
// compare the single threaded and multithreaded results
/*
if(compareData(result, gpu1Result, xsize*ysize, 0, 0.0f) == false);
compare(result, gpu1Result, xsize, ysize);
if(compareData(result, gpu2Result, xsize*ysize, 0, 0.0f) == false);
compare(result, gpu2Result, xsize, ysize);
*/
}
|
10,273 | #include <stdio.h>
#include <stdlib.h>
#include <cuda_runtime.h>
#define DATA_SIZE 1048576
#define THREAD_NUM 256
#define BLOCK_NUM 2
int data[DATA_SIZE];
static void GenerateNumbers(int *number, int size)
{
for(int i = 0; i < size; i++) {
number[i] = rand() % 10;
}
return;
}
static void print_device_prop(const cudaDeviceProp &prop)
{
printf("Device Name : %s.\n", prop.name);
printf("totalGlobalMem : %d.\n", prop.totalGlobalMem);
printf("sharedMemPerBlock : %d.\n", prop.sharedMemPerBlock);
printf("regsPerBlock : %d.\n", prop.regsPerBlock);
printf("warpSize : %d.\n", prop.warpSize);
printf("memPitch : %d.\n", prop.memPitch);
printf("maxThreadsPerBlock : %d.\n", prop.maxThreadsPerBlock);
printf("maxThreadsDim[0 - 2] : %d %d %d.\n", prop.maxThreadsDim[0], prop.maxThreadsDim[1], prop.maxThreadsDim[2]);
printf("maxGridSize[0 - 2] : %d %d %d.\n", prop.maxGridSize[0], prop.maxGridSize[1], prop.maxGridSize[2]);
printf("totalConstMem : %d.\n", prop.totalConstMem);
printf("major.minor : %d.%d.\n", prop.major, prop.minor);
printf("clockRate : %d.\n", prop.clockRate);
printf("textureAlignment : %d.\n", prop.textureAlignment);
printf("deviceOverlap : %d.\n", prop.deviceOverlap);
printf("multiProcessorCount : %d.\n", prop.multiProcessorCount);
}
bool init_cuda()
{
int count;
cudaGetDeviceCount(&count);
if(0 == count){
fprintf(stderr,"There is no device\n");
return false;
}
int i;
for(i = 0; i < count; i++){
cudaDeviceProp prop;
if(cudaSuccess == cudaGetDeviceProperties(&prop,i)){
if(prop.major >= 1){
break;
}
}
}
if(i == count){
fprintf(stderr,"There is no device supporting CUDA 1.x.\n");
return false;
}
cudaSetDevice(i);
return true;
}
__global__ static void sumOfSquares(int *num, int* result, clock_t* time)
{
extern __shared__ int shared[];
const int tid = threadIdx.x;
const int bid = blockIdx.x;
int i;
if(0 == tid){
time[bid] = clock();
}
shared[tid] = 0;
for(i = bid*THREAD_NUM + tid; i <= DATA_SIZE; i += THREAD_NUM * BLOCK_NUM){
shared[tid] += num[i] * num[i];
}
__syncthreads();
if(0 == tid){
for(i = 1; i < THREAD_NUM; i++){
shared[0] += shared[i];
}
result[bid] = shared[0];
}
if(0 == tid){
time[bid+BLOCK_NUM] = clock();
}
}
int main()
{
if(!init_cuda()){
return 0;
}
printf("CUDA initialize.\n");
//生成随机数
GenerateNumbers(data, DATA_SIZE);
int *gpudata, *result;
clock_t* time;
cudaMalloc((void **)&gpudata, sizeof(int)*DATA_SIZE);
cudaMalloc((void **)&result,sizeof(int)*BLOCK_NUM);
cudaMalloc((clock_t **)&time,sizeof(clock_t)*BLOCK_NUM*2);
cudaMemcpy(gpudata,data,sizeof(int)*DATA_SIZE,cudaMemcpyHostToDevice);
sumOfSquares<<<BLOCK_NUM,THREAD_NUM,THREAD_NUM*sizeof(int)>>>(gpudata,result,time);
int sum[BLOCK_NUM];
clock_t time_used[BLOCK_NUM*2];
cudaMemcpy(&sum,result,sizeof(int)*BLOCK_NUM,cudaMemcpyDeviceToHost);
cudaMemcpy(&time_used,time,sizeof(clock_t)*BLOCK_NUM*2,cudaMemcpyDeviceToHost);
cudaFree(gpudata);
cudaFree(result);
cudaFree(time);
int final_sum = 0;
for(int i = 0; i < BLOCK_NUM; i++){
final_sum += sum[i];
}
clock_t min_start, max_end;
min_start = time_used[0];
max_end = time_used[BLOCK_NUM];
for(int i = 1; i < BLOCK_NUM; i++) {
if(min_start > time_used[i])
min_start = time_used[i];
if(max_end < time_used[i + BLOCK_NUM])
max_end = time_used[i + BLOCK_NUM];
}
printf("sum(GPU):%d, time: %d\n", final_sum, max_end-min_start);
final_sum = 0;
for(int i = 0; i < DATA_SIZE; i++) {
final_sum += data[i] * data[i];
}
printf("sum (CPU): %d\n", final_sum);
return 0;
}
|
10,274 | //Based on the work of Andrew Krepps
#include <stdio.h>
#include <chrono>
__global__ void saxpy_pinned(int n, float a, float *x, float *y) {
int i = blockIdx.x*blockDim.x + threadIdx.x;
if (i < n)
y[i] = a*x[i] + y[i];
}
int main(int argc, char** argv)
{
// read command line arguments
int totalThreads = (1 << 20);
int blockSize = 256;
if (argc >= 2) {
totalThreads = atoi(argv[1]);
}
if (argc >= 3) {
blockSize = atoi(argv[2]);
}
int numBlocks = totalThreads/blockSize;
// validate command line arguments
if (totalThreads % blockSize != 0) {
++numBlocks;
totalThreads = numBlocks*blockSize;
printf("Warning: Total thread count is not evenly divisible by the block size\n");
printf("The total number of threads will be rounded up to %d\n", totalThreads);
}
printf("Total number of operations: %d\n", totalThreads);
// =======================================================================================
// Start my code
float *h_a_page, *h_b_page, *h_res_page;
float *h_a_pin, *h_b_pin, *h_res_pin;
float *d_a, *d_b;
// host pageable memory
h_a_page = (float*)malloc(totalThreads*sizeof(float));
h_b_page = (float*)malloc(totalThreads*sizeof(float));
h_res_page = (float*)malloc(totalThreads*sizeof(float));
// host pinned memory
cudaMallocHost((void**)&h_a_pin, totalThreads*sizeof(float));
cudaMallocHost((void**)&h_b_pin, totalThreads*sizeof(float));
cudaMallocHost((void**)&h_res_pin, totalThreads*sizeof(float));
// device memory
cudaMalloc((void**)&d_a, totalThreads*sizeof(float));
cudaMalloc((void**)&d_b, totalThreads*sizeof(float));
for(int i=0; i< totalThreads; i++) {
h_a_page[i] = 1.0f;
h_a_pin[i] = 1.0f;
h_b_page[i] = 2.0f;
h_b_pin[i] = 2.0f;
}
// Implement with paged memory
auto start_paged = std::chrono::high_resolution_clock::now();
cudaMemcpy(d_a, h_a_page, totalThreads*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_b_page, totalThreads*sizeof(float), cudaMemcpyHostToDevice);
saxpy_pinned<<<numBlocks, blockSize>>>(totalThreads, 1.0f, d_a, d_b);
cudaMemcpy(h_res_page, d_b, totalThreads*sizeof(float), cudaMemcpyDeviceToHost);
auto stop_paged = std::chrono::high_resolution_clock::now();
// Implement with pinned memory
auto start_pinned = std::chrono::high_resolution_clock::now();
cudaMemcpy(d_a, h_a_pin, totalThreads*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_b_pin, totalThreads*sizeof(float), cudaMemcpyHostToDevice);
saxpy_pinned<<<numBlocks, blockSize>>>(totalThreads, 1.0f, d_a, d_b);
cudaMemcpy(h_res_pin, d_b, totalThreads*sizeof(float), cudaMemcpyDeviceToHost);
auto stop_pinned = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> diff_paged = stop_paged-start_paged;
std::chrono::duration<double> diff_pinned = stop_pinned-start_pinned;
bool equal=true;
for(int i=0; i<totalThreads; i++) {
if(h_res_page[i] != h_res_pin[i]) {
printf("pagedResult[%d] = %f \npinnedResult[%d] = %f\nThese results do not match and they should!", i, h_res_page[i], i, h_res_pin[i]);
equal=false;
}
}
if(equal)
printf("All results for paged and pinned memory are the same!\n\n");
if(diff_paged.count() > diff_pinned.count())
printf("Pinned memory ran %fs faster than paged, or %fx as fast\n", diff_paged.count()-diff_pinned.count(), diff_paged.count()/diff_pinned.count());
else
printf("Paged memory ran %fs faster than pinned, or %fx as fast\n", diff_pinned.count()-diff_paged.count(), diff_pinned.count()/diff_paged.count());
printf("runtime for paged: %f\nruntime for pinned: %f\n\n", diff_paged.count(), diff_pinned.count());
cudaFree(d_a);
cudaFree(d_b);
cudaFreeHost(h_a_pin);
cudaFreeHost(h_b_pin);
cudaFreeHost(h_res_pin);
}
|
10,275 | #include "includes.h"
#define GLM_FORCE_CUDA
// LOOK-2.1 potentially useful for doing grid-based neighbor search
#ifndef imax
#define imax( a, b ) ( ((a) > (b)) ? (a) : (b) )
#endif
#ifndef imin
#define imin( a, b ) ( ((a) < (b)) ? (a) : (b) )
#endif
#define checkCUDAErrorWithLine(msg) checkCUDAError(msg, __LINE__)
/**
* Check for CUDA errors; print and exit if there was a problem.
*/
__global__ void kernIdentifyCellStartEnd(int N, int *particleGridIndices, int *gridCellStartIndices, int *gridCellEndIndices) {
// TODO-2.1
// Identify the start point of each cell in the gridIndices array.
// This is basically a parallel unrolling of a loop that goes
// "this index doesn't match the one before it, must be a new cell!"
} |
10,276 | #include <stdio.h>
/*
* 最简单的基于cuda在gpu并行运行的函数
*/
__global__ void firstParallel()
{
printf("This should be running in parallel.\n");
}
int main()
{
firstParallel<<<1, 10>>>();
cudaDeviceSynchronize();
return 0;
}
|
10,277 | #include <cuda.h>
#include <stdio.h>
__global__
void
helloKernel(){
if(threadIdx.x & 1 > 0){ //odd thread
printf("Hello world, from odd thread %d\n", threadIdx.x);
}else{
printf("Hello world, from even thread %d\n", threadIdx.x);
}
}
int
main(int argc, char* argv[]){
dim3 grid(1,1);
dim3 block(20,1);
helloKernel<<<grid, block>>>();
return 0;
//cudaDeviceReset(); //needed to flush printf cuda buffer
}
|
10,278 | #include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <cuda.h>
#define THREADS 32
#define WIDTH 4
#define HEIGHT 2
// See times between copy and traspose and realize the same operation
// with shared memory.
// Traspose is slower than copy...
// Traspose is need to shared memory to improve the performance...
// https://devblogs.nvidia.com/efficient-matrix-transpose-cuda-cc/
__global__ void copy(int *src, int *dest)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
int idy = blockIdx.y * blockDim.y + threadIdx.y;
if (idx >= WIDTH || idy >= HEIGHT) return;
dest[idy * WIDTH + idx] = src[idy * WIDTH + idx]; // Copio tal cual con los mismos indices facil... :)
}
__global__ void copy_shared(int *src, int *dst)
{
__shared__ int mem[THREADS][THREADS + 1];
int idx = blockIdx.x * blockDim.x + threadIdx.x;
int idy = blockIdx.y * blockDim.y + threadIdx.y;
if (idx >= WIDTH || idy >= HEIGHT) return;
mem[threadIdx.x][threadIdx.y] = src[idy * WIDTH + idx]; // Añado el valor en la memoria compartida...
__syncthreads();
dst[idy * WIDTH + idx] = mem[threadIdx.x][threadIdx.y]; // Añado en su posicion natural el valor de la memoria
// compartida...
}
__global__ void traspose(int *src, int *dest)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
int idy = blockIdx.y * blockDim.y + threadIdx.y;
if (idx >= WIDTH || idy >= HEIGHT) return;
dest[idx * HEIGHT + idy] = src[idy * WIDTH + idx]; // Cambio el valor de la matriz a la traspuesta
// con los índices de acceso a la matriz...
}
__global__ void traspose_shared(int *src, int *dst)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
int idy = blockIdx.y * blockDim.y + threadIdx.y;
if (idx >= WIDTH || idy >= HEIGHT) return;
__shared__ int mem[THREADS][THREADS + 1];
mem[threadIdx.x][threadIdx.y] = src[idx * HEIGHT + idy]; // Hago las posiciones traspuestas
// en la memoria compartida...
__syncthreads();
dst[idy * WIDTH + idx] = mem[threadIdx.x][threadIdx.y]; // Añado en su posicion natural el valor de la shared
// que tiene el valor de la traspuesta....
}
__global__ void matrixAddPitch (int *a, int *b, int*c, int pitch) {
int idx = threadIdx.x + blockIdx.x * blockDim.x;
int idy = threadIdx.y + blockIdx.y * blockDim.y;
if (idx > pitch || idy > HEIGHT) return;
c[idy * pitch + idx] = a[idy * pitch + idx] + b[idy * pitch + idx];
}
unsigned long get_time()
{
struct timespec ts;
if (clock_gettime(0, &ts) < 0) {
fprintf(stderr, "Error calc time... %s\n", strerror(errno));
exit(1);
}
return ts.tv_sec * 1000000000L + ts.tv_nsec;
}
void mi_malloc_int(int **i, int size) {
*i = (int *) malloc( sizeof(int) * size);
if (*i == NULL) {
fprintf(stderr, "Error malloc %s\n", strerror(errno));
exit(1);
}
memset(*i, 0, sizeof(int) * size);
}
void init(int *h_v) {
for (int i = 0; i < HEIGHT; i++) {
for (int j = 0; j < WIDTH; ++j) {
h_v[i * WIDTH + j] = i * WIDTH + j;
}
}
}
void print_matrix(const int *matrix, const int w, const int h) {
fprintf(stdout, "%s\n", "Print matrix...");
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; ++j) {
fprintf(stdout, "%5d", matrix[i * w + j]);
}
fprintf(stdout, "%s\n", "");
}
fprintf(stdout, "%s\n", "");
}
void addPitch()
{
int n = WIDTH * HEIGHT;
dim3 t (16, 16);
dim3 b ( (WIDTH - 1) / t.x + 1, (HEIGHT - 1) / t.y + 1);
int *h_a, *h_b, *h_c;
int *d_a, *d_b, *d_c;
int size = sizeof(int) * n;
size_t pitch;
h_a = (int *) malloc (size);
h_b = (int *) malloc (size);
h_c = (int *) malloc (size);
for (int i = 0; i < n; i++) {
h_a[i] = i;
h_b[i] = i;
}
cudaMallocPitch(&d_a, &pitch, WIDTH * sizeof(int), HEIGHT);
cudaMallocPitch(&d_b, &pitch, WIDTH * sizeof(int), HEIGHT);
cudaMallocPitch(&d_c, &pitch, WIDTH * sizeof(int), HEIGHT);
cudaMemcpy2D (d_a, pitch, h_a, WIDTH * sizeof(int), WIDTH * sizeof(int), HEIGHT, cudaMemcpyHostToDevice);
cudaMemcpy2D (d_b, pitch, h_b, WIDTH * sizeof(int), WIDTH * sizeof(int), HEIGHT, cudaMemcpyHostToDevice);
matrixAddPitch <<<b, t>>> (d_a, d_b, d_c, pitch / sizeof(int));
cudaMemcpy2D (h_c, WIDTH * sizeof(int), d_c, pitch, WIDTH * sizeof(int), HEIGHT, cudaMemcpyDeviceToHost);
print_matrix(h_c, HEIGHT, WIDTH);
free(h_a);
free(h_b);
free(h_c);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
}
void traspose() {
int *matrix = NULL;
int *dev_matrix = NULL;
int *dev_traspose = NULL;
mi_malloc_int(&matrix, WIDTH * HEIGHT);
init(matrix);
print_matrix(matrix, WIDTH, HEIGHT);
cudaMalloc(&dev_matrix, sizeof(int) * WIDTH * HEIGHT);
// &dst, size...
cudaMemcpy(dev_matrix, matrix, sizeof(int) * WIDTH * HEIGHT, cudaMemcpyHostToDevice);
// dst, src, size, cudaMemcpyHostToDevice...;
cudaMalloc(&dev_traspose, sizeof(int) * WIDTH * HEIGHT);
// &dst, size...
cudaMemset(dev_traspose, 0, sizeof(int) * WIDTH * HEIGHT);
// dst, value byte 0, size...
dim3 t(THREADS, THREADS);
dim3 b((WIDTH - 1) / t.x + 1, (HEIGHT - 1) / t.y + 1);
// ... START PARARELL CODE ...
unsigned long now = get_time();
traspose<<<b, t>>>(dev_matrix, dev_traspose);
// Call kernel << b , t >> (a , b);
cudaMemcpy(matrix, dev_traspose, sizeof(int) * WIDTH * HEIGHT, cudaMemcpyDeviceToHost);
// dest, src, size, cudaMemcpyDeviceToHost;
fprintf(stdout, "Time : %lf ms\n", (get_time() - now) / 1000000.0f);
// ... END PARARELL CODE ...
print_matrix(matrix, HEIGHT, WIDTH);
fprintf(stdout, "Num Blocks (x:%d y:%d)\n", b.x, b.y);
}
int main(int argc, char const *argv[])
{
traspose();
return 0;
}
|
10,279 | #include <stdio.h>
#include <cuda.h>
#define SIZE 64
#define cudaCheckError() { \
cudaError_t e=cudaGetLastError(); \
if(e!=cudaSuccess) { \
printf("Cuda failure %s:%d: '%s'\n",__FILE__,__LINE__,cudaGetErrorString(e)); \
exit(0); \
} \
}
__global__ void kernel(unsigned int * x){
atomicInc(&x[0],100);
__syncthreads();
printf("hi I'm tid %u - %u\n", threadIdx.x, x[0]);
}
int main(){
//! unsigned int* x;
//! x = (unsigned int*) malloc(sizeof(unsigned int) * SIZE);
//! *x=0;
unsigned int* dx;
cudaMalloc( (void**) &dx, SIZE*sizeof(unsigned int)); cudaCheckError();
//! cudaMemcpy(dx ,x , sizeof(unsigned int)* SIZE , cudaMemcpyHostToDevice); // did not make a difference
kernel<<< 1, SIZE >>>(dx);
cudaDeviceSynchronize(); cudaCheckError();
return 0;
}
|
10,280 | #include "motionPlanningProblem.cuh"
void printMotionPlanningProblem(MotionPlanningProblem mpp, std::ostream& stream) {
} |
10,281 | /*
* This is a CUDA code that performs an iterative reverse edge
* detection algorithm.
*
* Training material developed by James Perry and Alan Gray
* Copyright EPCC, The University of Edinburgh, 2013
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#include <sys/types.h>
//#include <sys/time.h>
#include<chrono>
#include <cuda_runtime_api.h>
#include <cuda.h>
#include "device_launch_parameters.h"
/* Utility Functions */
using std::chrono::time_point;
using std::chrono::system_clock;
/*
* Function to get an accurate time reading
*/
time_point<system_clock> get_current_time()
{
/*
static int start = 0, startu = 0;
struct timeval tval;
double result;
if (gettimeofday(&tval, NULL) == -1)
result = -1.0;
else if(!start) {
start = tval.tv_sec;
startu = tval.tv_usec;
result = 0.0;
}
else
result = (double) (tval.tv_sec - start) + 1.0e-6*(tval.tv_usec - startu);
return result;
*/
return std::chrono::system_clock::now();
}
/* Read the input file containing the edge data */
void datread(char *filename, void *vx, int nx, int ny)
{
FILE *fp;
int nxt, nyt, i, j, t;
float *x = (float *) vx;
if (NULL == (fp = fopen(filename,"r")))
{
fprintf(stderr, "datread: cannot open <%s>\n", filename);
exit(-1);
}
fscanf(fp,"%d %d",&nxt,&nyt);
if (nx != nxt || ny != nyt)
{
fprintf(stderr,
"datread: size mismatch, (nx,ny) = (%d,%d) expected (%d,%d)\n",
nxt, nyt, nx, ny);
exit(-1);
}
for (j=0; j<ny; j++)
{
for (i=0; i<nx; i++)
{
fscanf(fp,"%d", &t);
x[(ny-j-1)*nx + i] = (float)t;
}
}
fclose(fp);
}
/* Write the output image as a PGM file */
void pgmwrite(char *filename, void *vx, int nx, int ny)
{
FILE *fp;
int i, j, k, grey;
float xmin, xmax, tmp;
float thresh = 255.0;
float *x = (float *) vx;
if (NULL == (fp = fopen(filename,"w")))
{
fprintf(stderr, "pgmwrite: cannot create <%s>\n", filename);
exit(-1);
}
/*
* Find the max and min absolute values of the array
*/
xmin = fabs(x[0]);
xmax = fabs(x[0]);
for (i=0; i < nx*ny; i++)
{
if (fabs(x[i]) < xmin) xmin = fabs(x[i]);
if (fabs(x[i]) > xmax) xmax = fabs(x[i]);
}
fprintf(fp, "P2\n");
fprintf(fp, "# Written by pgmwrite\n");
fprintf(fp, "%d %d\n", nx, ny);
fprintf(fp, "%d\n", (int) thresh);
k = 0;
for (j=ny-1; j >=0 ; j--)
{
for (i=0; i < nx; i++)
{
/*
* Access the value of x[i][j]
*/
tmp = x[j*nx+i];
/*
* Scale the value appropriately so it lies between 0 and thresh
*/
if (xmin < 0 || xmax > thresh)
{
tmp = (int) ((thresh*((fabs(tmp-xmin))/(xmax-xmin))) + 0.5);
}
else
{
tmp = (int) (fabs(tmp) + 0.5);
}
/*
* Increase the contrast by boosting the lower values
*/
grey = (int) (thresh * sqrt(tmp/thresh));
fprintf(fp, "%3d ", grey);
if (0 == (k+1)%16) fprintf(fp, "\n");
k++;
}
}
if (0 != k%16) fprintf(fp, "\n");
fclose(fp);
}
/* Simple utility function to check for CUDA runtime errors */
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);
}
}
|
10,282 | #include "includes.h"
__global__ void decat(float* output1, float* output2, float* output3, float* output4, size_t num1, size_t num2, size_t num3, size_t num4, size_t maxNum, float* input, const int numPerBatch)
{
size_t i = blockDim.x * blockIdx.x + threadIdx.x;
for(;i < maxNum; i += size_t(blockDim.x * gridDim.x)){
size_t batchIdx = i / numPerBatch; // which batch this thread is working in
const int batchOffset = i - batchIdx * numPerBatch; // offset of current thread in current batch
if(batchOffset < num1){ // first output
output1[batchOffset + batchIdx * num1] = input[i];
}
else if(batchOffset < (num1 + num2)){ // second output
output2[(batchOffset - num1) + batchIdx * num2] = input[i];
}
else if(batchOffset < (num1 + num2 + num3)){ // third input
output3[(batchOffset - (num1 + num2)) + batchIdx * num3] = input[i];
}
else{ // fourth input
output4[(batchOffset - (num1 + num2 + num3)) + batchIdx * num4] = input[i];
}
}
} |
10,283 | #include <cuda.h>
#include <stdio.h>
__global__ void K1() {
unsigned num = 0;
for (unsigned ii = 0; ii < threadIdx.x; ++ii)
num += ii;
printf("K1: %d\n", threadIdx.x);
}
__global__ void K2() {
printf("K2\n");
}
int main() {
cudaStream_t s1, s2;
cudaStreamCreate(&s1);
cudaStreamCreate(&s2);
K1<<<1, 1024, 0, s1>>>();
K2<<<1, 32, 0, s2>>>();
cudaDeviceSynchronize();
return 0;
}
|
10,284 | #define image_height 4096
#define image_width 4096
#ifndef filter_height
#define filter_height 17
#endif
#ifndef filter_width
#define filter_width 17
#endif
#define border_height ((filter_height/2)*2)
#define border_width ((filter_width/2)*2)
#define input_height (image_height + border_height)
#define input_width (image_width + border_width)
#ifndef block_size_x
#define block_size_x 16
#endif
#ifndef block_size_y
#define block_size_y 16
#endif
#ifndef block_size_z
#define block_size_z 1
#endif
#ifndef tile_size_x
#define tile_size_x 1
#endif
#ifndef tile_size_y
#define tile_size_y 1
#endif
#define i_end min(block_size_y*tile_size_y+border_height, input_height)
#define j_end min(block_size_x*tile_size_x+border_width, input_width)
/*
* If requested, we can use the __ldg directive to load data through the
* read-only cache.
*/
#define USE_READ_ONLY_CACHE read_only
#if USE_READ_ONLY_CACHE == 1
#define LDG(x, y) __ldg(x+y)
#elif USE_READ_ONLY_CACHE == 0
#define LDG(x, y) x[y]
#endif
__constant__ float d_filter[33*33]; //large enough for the largest filter
/*
* If use_padding == 1, we introduce (only when necessary) a number of padding
* columns in shared memory to avoid shared memory bank conflicts
*
* padding columns are only inserted when block_size_x is not a multiple of 32 (the assumed number of memory banks)
* and when the width of the data needed is not a multiple of 32. The latter is because some filter_widths never
* cause bank conflicts.
*
* If not passed as a tunable parameter, padding is on by default
*/
#define shared_mem_width (block_size_x*tile_size_x+border_width)
#ifndef use_padding
#define use_padding 1
#endif
#if use_padding == 1
#if (((block_size_x % 32)!=0) && (((shared_mem_width-block_size_x)%32) != 0))
// next line uses &31 instead of %32, because % in C is remainder not modulo
#define padding_columns ((32 - (border_width + block_size_x*tile_size_x - block_size_x)) & 31)
#undef shared_mem_width
#define shared_mem_width (block_size_x*tile_size_x+border_width+padding_columns)
#endif
#endif
__global__ void convolution_kernel(float *output, float *input, float *filter) {
int ty = threadIdx.y;
int tx = threadIdx.x;
int by = blockIdx.y * block_size_y * tile_size_y;
int bx = blockIdx.x * block_size_x * tile_size_x;
//shared memory to hold all input data need by this thread block
__shared__ float sh_input[block_size_y*tile_size_y+border_height][shared_mem_width];
//load all input data needed by this thread block into shared memory
#pragma unroll
for (int i=ty; i<i_end; i+=block_size_y) {
#pragma unroll
for (int j=tx; j<j_end; j+=block_size_x) {
#if ((image_height%(block_size_y*tile_size_y)!=0) || (image_width%(block_size_x*tile_size_x)!=0))
int y = by+i;
int x = bx+j;
if (y < input_height && x < input_width) {
sh_input[i][j] = LDG(input, y*input_width+x);
}
#else
sh_input[i][j] = LDG(input, (by+i)*input_width + (bx+j));
#endif
}
}
__syncthreads();
//thread-local registers to hold local sums
float sum[tile_size_y][tile_size_x];
#pragma unroll
for (int yi=0; yi<tile_size_y; yi++) {
#pragma unroll
for (int xi=0; xi<tile_size_x; xi++) {
sum[yi][xi] = 0.0f;
}
}
//for each filter weight
#pragma unroll
for (int i=0; i < filter_height; i++) {
#pragma unroll
for (int j=0; j < filter_width; j++) {
#pragma unroll
for (int yi=0; yi<tile_size_y; yi++) {
#pragma unroll
for (int xi=0; xi<tile_size_x; xi++) {
sum[yi][xi] += sh_input[ty+yi*block_size_y+i][tx+xi*block_size_x+j] * d_filter[i*filter_width+j];
}
}
}
}
//store results to global memory
#pragma unroll
for (int yi=0; yi<tile_size_y; yi++) {
#pragma unroll
for (int xi=0; xi<tile_size_x; xi++) {
#if ((image_height%(block_size_y*tile_size_y)!=0) || (image_width%(block_size_x*tile_size_x)!=0))
int y = by+ty+yi*block_size_y;
int x = bx+tx+xi*block_size_x;
if (y < image_height && x < image_width) {
output[y * image_width + x] = sum[yi][xi];
}
#else
output[(by+ty+yi*block_size_y) * image_width + bx+tx+xi*block_size_x] = sum[yi][xi];
#endif
}
}
}
__global__ void convolution_naive(float *output, float *input, float *filter) {
int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;
int i, j;
float sum = 0.0;
if (y < image_height && x < image_width) {
for (j = 0; j < filter_height; j++) {
for (i = 0; i < filter_width; i++) {
sum += input[(y + j) * input_width + (x + i)] * filter[j * filter_width + i];
}
}
output[y * image_width + x] = sum;
}
}
|
10,285 | extern "C"
__global__ void K_SYNC_UINT_DEP128 (unsigned int *ts, unsigned int* out, unsigned int p1, unsigned int p2, int its)
{
}
|
10,286 | #include <stdio.h>
#define NUM_BLOCKS (1)
#define BLOCK_WIDTH (4)
__global__
void hello()
{
int idx = threadIdx.x;
// all the threads in the block can access the block-shared memory
__shared__ int array[BLOCK_WIDTH];
// initize the memory
array[idx] = threadIdx.x;
// stop all the threads to read before initilized completely
printf("Hello world! I'm a thread in block %d\n", idx);
__syncthreads();
printf("Hello world! I'm a thread in block %d\n", idx);
if (idx < BLOCK_WIDTH-1)
{
// pre-read the memory
int temp = array[idx+1];
__syncthreads();
// when read over, write it
array[idx] = temp;
__syncthreads(); // use sync to assure all the memory have written
}
}
int main()
{
hello<<<NUM_BLOCKS, BLOCK_WIDTH>>>();
// force the printf()s to flush
cudaDeviceSynchronize();
printf("That's all!\n");
return 0;
} |
10,287 | #define tamBloque 64
__constant__ int mascaraX[3][3];
__constant__ int mascaraY[3][3];
// Kernel que se ejecutará en el grid de la GPU
__global__ void sobelKernel(float *entrada, float *salida, int filas, int columnas){
int sumx = 0;
int sumy = 0;
int SUM = 0;
int x, y;
int i, j, pix, piy;
int R, G, B, NC, posR, posG, posB;
float newPixel;
y= blockIdx.y;
x= blockIdx.x * blockDim.x + threadIdx.x;
if (y == 0 || y == filas-1 || x==0 || x == columnas-1){
SUM = 0;
}
else{
for(i=-1; i<=1; i++) {
for(j=-1; j<=1; j++) {
pix = j + x;
piy = i + y;
posR= piy*columnas + pix; // posición en el vector del componente R del pixel sobre el que trabajamos
R = (int)entrada[posR]; // imagen(pix,piy,0,0);
posG= filas*columnas + piy*columnas + pix; // posición en el vector del componente G del pixel sobre el que trabajamos
G = (int)entrada[posG]; // imagen(pix,piy,0,1);
posB= 2*filas*columnas + piy*columnas + pix; // posición en el vector del componente B del pixel sobre el que trabajamos
B = (int)entrada[posB]; // imagen(pix,piy,0,2);
NC = (R+G+B)/3;
sumx = sumx + (NC) * mascaraX[j+1][i+1];
sumy = sumy + (NC) * mascaraY[j+1][i+1];
}
}
SUM = abs(sumx) + abs(sumy);
}
if(SUM>255){
SUM=255;
}
newPixel = 255 - (float)(SUM);
salida[y*columnas + x] = newPixel; // componente R
salida[filas*columnas + y*columnas + x] = newPixel; // componente G
salida[2*filas*columnas + y*columnas + x] = newPixel; // componente B
}
// Función que lanza la ejecución de vectores en la GPU
void calcularSobelCuda (float *hEntrada, float *hSalida, int filas, int columnas){
float *dEntrada, *dSalida;
int tam;
dim3 DimGrid, DimBlock;
int Gx [3][3]; int Gy [3][3];
// Sobel Horizontal Mask
Gx[0][0] = 1; Gx[0][1] = 0; Gx[0][2] = -1;
Gx[1][0] = 2; Gx[1][1] = 0; Gx[1][2] = -2;
Gx[2][0] = 1; Gx[2][1] = 0; Gx[2][2] = -1;
// Sobel Vertical Mask
Gy[0][0] = 1; Gy[0][1] = 2; Gy[0][2] = 1;
Gy[1][0] = 0; Gy[1][1] = 0; Gy[1][2] = 0;
Gy[2][0] = -1; Gy[2][1] =-2; Gy[2][2] = -1;
// Transferimos las máscaras a la memoria constante de la GPU
cudaMemcpyToSymbol(mascaraX, Gx, 3*3*sizeof(int));
cudaMemcpyToSymbol(mascaraY, Gy, 3*3*sizeof(int));
// Espacio que ocupa en memoria la imagen
tam= filas * columnas * 3 * sizeof(float); // 3 colores (R, G, B)
// Reservamos espacio y copiamos en GPU la imagen de entrada
cudaMalloc((void **) &dEntrada, tam);
cudaMemcpy(dEntrada,hEntrada,tam,cudaMemcpyHostToDevice);
// Reservamos espacio en GPU para la imagen de salida
cudaMalloc((void **) &dSalida, tam);
// tamaño del grid y de los bloques de hebras
DimBlock= dim3(tamBloque, 1, 1); // bloques de tamBloque hebras
DimGrid= dim3( ((columnas-1)/tamBloque)+1, filas, 1); // grid 2D, x= bloques necesarios para cubrir 1 fila de la imagen, y= n filas imagen
// Llamada al kernel
sobelKernel<<<DimGrid,DimBlock>>>(dEntrada,dSalida,filas,columnas);
// Copia de resultados GPU -> host
cudaMemcpy(hSalida,dSalida,tam,cudaMemcpyDeviceToHost);
// Liberación de memoria en GPU
cudaFree(dEntrada);
cudaFree(dSalida);
}
|
10,288 | #include "includes.h"
__global__ void add(int a, int b, int *c)
{
*c = a + b;
} |
10,289 | #include <cuda.h>
#include <stdio.h>
#include <curand.h>
int main() {
curandGenerator_t gen;
curandCreateGenerator(&gen, CURAND_RNG_PSEUDO_DEFAULT);
curandSetPseudoRandomGeneratorSeed(gen, 1234);
float *hostData, *devData;
hostData = (float *)malloc(2*sizeof(float));
cudaMalloc(&devData, 2*sizeof(float));
curandGenerateUniform(gen, devData, 2);
cudaMemcpy(hostData, devData, 2*sizeof(float), cudaMemcpyDeviceToHost);
printf("ran1 = %e\nran2 = %e\n", hostData[0], hostData[1]);
curandDestroyGenerator(gen); cudaFree(devData); free(hostData);
}
|
10,290 | #include <stdio.h>
#include <cuda.h>
#include <stdlib.h>
#include <math.h>
#include <sys/time.h>
#include <string.h>
#include <stdarg.h>
//#include <omp.h>
#define SEED 1
#define VERBOSE 0
double getclock();
void checkCUDAError(const char *);
extern void freeAllmem();
extern void init_kernel(int numarray,...);
int main(int argc, char** argv){
if(VERBOSE){//Get device information
int count;
cudaGetDeviceCount(&count);
cudaDeviceProp prop;
cudaGetDeviceProperties(&prop,0);
printf("Compute capability: %d.%d\n",prop.major,prop.minor);
printf("Number of GPUs: %d\n",count);
printf("Multiprocessor count: %d\n",prop.multiProcessorCount);
printf("Clock rate: %luKhz\n",prop.clockRate/1000);
printf("Total Global Memory: %luMB\n",(unsigned int)prop.totalGlobalMem/1000000);
printf("Total Constant Memory: %d\n",prop.totalConstMem);
printf("Shared memory per block: %d\n",prop.sharedMemPerBlock);
printf("1-D Texture Max size: %d\n",prop.maxTexture1D);
printf("Number of registers per block: %d\n",prop.regsPerBlock);
printf("Can I map host memory: %d\n",prop.canMapHostMemory);
printf("Max number of threads per block: %d\n",prop.maxThreadsPerBlock);
printf("Max number of blocks in a grid [0]: %d\n",prop.maxGridSize[0]);
printf("Max number of blocks in a grid [1]: %d\n",prop.maxGridSize[1]);
printf("Max number of blocks in a grid [2]: %d\n",prop.maxGridSize[2]);
printf("Max Texture dimensions 2D: %lu\n",prop.maxTexture2D[2]);
printf("Concurrent Kernels: %d\n",prop.concurrentKernels);
printf("Threads in a warp: %d\n",prop.warpSize);
//some general cpu info
printf("size of float (cpu): %d\n",sizeof(float));
printf("size of double (cpu): %d\n",sizeof(double));
printf("size of unsigned int (cpu): %d\n",sizeof(unsigned int));
printf("size of unsigned long (cpu): %d\n",sizeof(unsigned long));
printf("..................................\n\n");
}
int i;
double cstart,cend,celapsed;
float elapsedtime; // CUDA device timer
cudaEvent_t start,stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
dim3 blocks;
dim3 threads;
// allocate and transfer data
init_kernel(8,0,2,2,300,0,400,1,1000);
printf("Successfully allocated device memory.\n\n");
//for-loop in number of configs.
// blocks.x=?;
// blocks.y=?;
// blocks.z=?;
// threads.x=?;
// threads.y=?;
// threads.z=?;
// cstart=getclock();
// kernel_name<<<blocks,threads,1>>>(<kernel_args>);
// cudaEventRecord(stop,0);
// cudaEventSynchronize(stop); // event barrier
// cend=getclock();
// celapsed=cend-cstart;
// cudaEventElapsedTime(&elapsedtime,start,stop);
//end for-loop
cudaEventDestroy(start);
cudaEventDestroy(stop);
freeAllmem();
exit(EXIT_SUCCESS);
}
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);
}
}
double getclock(){
struct timezone tzp;
struct timeval tp;
gettimeofday (&tp, &tzp);
return (tp.tv_sec + tp.tv_usec*1.0e-6);
}
|
10,291 | #include<stdio.h>
int main(){
int nDevices;
cudaGetDeviceCount(&nDevices);
printf("Device count = %d\n",nDevices);
return 0;
}
|
10,292 | #include <stdio.h>
#include <iostream>
#include <ctime>
using namespace std;
void host_init(float *arr, int n, float init_val){
for (int i=0; i < n; i++)
arr[i] = init_val;
}
void host_matmul(float *h_a, float *h_b, float *h_c, int m, int n, int k){
// h_a (mxk); h_b (kxn); h_c (mxn)
for (int row = 0; row < m; row++){
for (int col = 0; col < n; col++){
float sum = 0;
for (int kk = 0; kk < k; kk++){
float a = h_a[row*k + kk];
float b = h_b[kk*n + col];
sum += a * b;
}
h_c[row*n + col] = sum;
}
}
}
__global__
void cuda_matmul(float *d_a, float *d_b, float *d_c, int m, int n, int k){
int col = blockIdx.x*blockDim.x + threadIdx.x;
int row = blockIdx.y*blockDim.y + threadIdx.y;
if (row < m && col < n){
float sum = 0;
for (int i=0; i < k; i++){
sum += d_a[row*k + i] * d_b[i*n + col];
}
d_c[row*n + col] = sum;
}
}
void cudaError_check(cudaError_t err){
if (err != cudaSuccess){
printf("GPUassert: %s %s %d\n", cudaGetErrorString(err), __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
}
int main(){
float *h_a, *h_b, *h_c, *h_c_cpy;
float *d_a, *d_b, *d_c;
// h_a dimensions = MxK
// h_b dimensions = KxN
// h_c dimensions = MxN
int m = 1024; //
int n = 1024; //
int k = 1024; //
size_t size_ha = k*m*sizeof(float);
size_t size_hb = k*n*sizeof(float);
size_t size_hc = m*n*sizeof(float);
clock_t start, stop;
//################## HOST Start ###################//
h_a = (float*) malloc (size_ha);
h_b = (float*) malloc (size_hb);
h_c = (float*) malloc (size_hc);
h_c_cpy = (float*) malloc (size_hc);
host_init(h_a, k*m, 1);
host_init(h_b, n*k, 2);
host_init(h_c, n*m, 0);
host_init(h_c_cpy, n*m, 0);
start = clock();
host_matmul(h_a, h_b, h_c, m, n, k);
stop = clock();
double cpu_duration = (stop - start) / (double) CLOCKS_PER_SEC;
//################## HOST End ###################//
//################## CUDA Start ###################//
cudaError_t err ;
err = cudaMalloc((void **) &d_a, size_ha);
cudaError_check(err);
err = cudaMemcpy(d_a, h_a, size_ha, cudaMemcpyHostToDevice);
cudaError_check(err);
err = cudaMalloc((void **) &d_b, size_hb);
cudaError_check(err);
err = cudaMemcpy(d_b, h_b, size_hb, cudaMemcpyHostToDevice);
cudaError_check(err);
err = cudaMalloc((void **) &d_c, size_hc);
cudaError_check(err);
//Kernel invocation
int num_threads_per_block = 16;
dim3 gridDim ((m-1)/num_threads_per_block + 1, (n-1)/num_threads_per_block + 1, 1);
dim3 blockDim (num_threads_per_block, num_threads_per_block, 1);
start = clock();
cuda_matmul<<<gridDim, blockDim>>>(d_a, d_b, d_c, m, n, k);
err = cudaDeviceSynchronize();
stop = clock();
cudaError_check(err);
err = cudaMemcpy(h_c_cpy, d_c, size_hc, cudaMemcpyDeviceToHost);
cudaError_check(err);
double gpu_duration = (stop - start) / (double) CLOCKS_PER_SEC;
//################## CUDA End ###################//
int success = 1;
for (int i = 0; i < n*m; i++){
if (h_c[i] != h_c_cpy[i]){
success = 0;
printf("Failure at idx: %d\n", i);
break;
}
}
if (success == 1)
printf("Success\n");
printf("CPU Duration: %0.3f secs \n", cpu_duration);
printf("GPU Duration: %0.3f secs \n", gpu_duration);
return 1;
}
|
10,293 | /////*Author Luca Zelioli*/
////
////cuda inclusion
//#include <cuda.h>
//#include <cuda_runtime.h>
//#include <device_launch_parameters.h>
//#include <device_functions.h>
//#include <cuda_runtime_api.h>
//#include <device_atomic_functions.h>
////c++ iinclusion
//#include <iostream>
//#include <stdio.h>
//
////math library
//#define _USE_MATH_DEFINES
//#include <math.h>
//#include <cmath>
//
//#include <string>
//#include <ctime> // maybe not needed
//
////Histogram ORI 180
//#define HISTOGRAM_DEGREE 720
//
////define the thread in blocks
//#define THREADS_IN_BLOCKS 256
//
////project inclusion
//#include "function.h";
//
//using namespace std;
//
////Cuda error handling start here
//
//inline void error_check(cudaError_t err, const char*file, int line)
//{
// if (err != cudaSuccess) {
// ::fprintf(stderr, "CUDA ERROR at %s[%d] : %s\n", file, line, cudaGetErrorString(err));
// std::cout << "General error at %s[%d] : %s\n", file, line, cudaGetErrorString(err);
// }
//}
//
//#define CUDA_CHECK(err) do { error_check(err, __FILE__, __LINE__); } while(0)
//
//__global__ void DarkMatterMaster(int size, double* device_real, double* device_flat, long int* device_resultDD, long int* device_resultDR, long int* device_resultRR)
//{
//
// //init all the histo to 0
// for (int i = 0; i < HISTOGRAM_DEGREE; i++)
// {
// device_resultDD[i] = 0;
// device_resultDR[i] = 0;
// device_resultRR[i] = 0;
// }
//
// //first thing copnvert in arc minutes to rad
// int index = threadIdx.x + blockIdx.x * blockDim.x;
//
// //qui inizia galaxy comp
// int i = threadIdx.x + blockIdx.x * blockDim.x;
// int j = threadIdx.y + blockIdx.y * blockDim.y;
// //int j = 0;
// if(i < size - 3)
// {
// //debug
// // printf("GPU - j = %d, i =%d\n", j, i);
// //allocate temp DD
// double tempDD = acos(sin(device_real[j + 1]) * sin(device_real[i + 3]) + cos(device_real[j + 1])*cos(device_real[i + 3])*cos(device_real[j] - device_real[i + 2]));
// //++device_resultDD[(int)(acos(sin(device_real[j + 1]) * sin(device_real[i + 3]) + cos(device_real[j + 1])*cos(device_real[i + 3])*cos(device_real[j] - device_real[i + 2])) * 180 / M_PI * 4)];
// //debug
// printf("TempDD -> %f\n", tempDD);
// //allocate temp DR
// double tempDR = acos(sin(device_real[j + 1]) * sin(device_flat[i + 1]) + cos(device_real[j + 1]) * cos(device_flat[i + 1]) * cos(device_real[j] - device_flat[i]));
// //debug
// printf("TempDR -> %f\n", tempDR);
// //allocate temp RR
// double tempRR = acos(sin(device_flat[j + 1]) * sin(device_flat[i + 3]) + cos(device_flat[j + 1])*cos(device_flat[i + 3])*cos(device_flat[j] - device_flat[i + 2]));
// //debug
// printf("TempRR -> %f\n", tempRR);
// //atomicAdd
// ++device_resultDD[(int)(tempDD * 180 / M_PI * 4)];
// ++device_resultDR[(int)(tempDR * 180 / M_PI * 4)];
// ++device_resultRR[(int)(tempRR * 180 / M_PI * 4)];
// //Test add 1 to go next couple of number CONTROLLARE
// //i = i + 1;
// //j = j + 1;
// i += blockDim.x * gridDim.x;
// j += blockDim.y * gridDim.y;
//
// }
//
// //sync the thread
// __syncthreads();
//}
//
//int main(int argc, char* argv[])
//{
// //start clock
// clock_t masterStart = clock();
// //device counter
// int deviceCount = 0;
//
// //double host_real[5] = { 4646.98, 3749.51, 4644.35, 3749.52 };
// //double host_flat[5] = { 840.961426, 387.991697, 387.368692, 2967.285746 };
// double* host_real = CreateVector("Data/data_100k_arcmin.txt");
// double* host_flat = CreateVector("Data/flat_100k_arcmin.txt");
// size_t arraySize = GetVectorSize("Data/data_100k_arcmin.txt");
// //size_t arraySize = 2;
//
// double* host_resultDD = (double*)malloc(HISTOGRAM_DEGREE * sizeof(double));
// double* host_resultDR = (double*)malloc(HISTOGRAM_DEGREE * sizeof(double));
// double* host_resultRR = (double*)malloc(HISTOGRAM_DEGREE * sizeof(double));
//
// double * device_real;
// double * device_flat;
// long int * device_resultDD;
// long int * device_resultDR;
// long int * device_resultRR;
//
// if (cudaSuccess != cudaMalloc((void**)&device_real, arraySize * sizeof(double)))
// {
// std::cout << "Error in allocating device_real memory" << std::endl;
// }
//
// if (cudaSuccess != cudaMalloc((void**)&device_flat, arraySize * sizeof(double)))
// {
// std::cout << "Error in allocating device_host memory" << std::endl;
// }
//
// if (cudaSuccess != cudaMalloc((void**)&device_resultDD, HISTOGRAM_DEGREE * sizeof(long int))) //usare int o lo ng int
// {
// std::cout << "Error in allocating device_resultDD memory" << std::endl;
// }
//
// if (cudaSuccess != cudaMalloc((void**)&device_resultDR, HISTOGRAM_DEGREE * sizeof(long int)))
// {
// std::cout << "Error in allocating device_resultDR memory" << std::endl;
// }
//
// if (cudaSuccess != cudaMalloc((void**)&device_resultRR, HISTOGRAM_DEGREE * sizeof(long int)))
// {
// std::cout << "Error in allocating device_resultRR memory" << std::endl;
// }
//
// cudaMemcpy(device_real, host_real, arraySize * sizeof(double), cudaMemcpyHostToDevice);
// cudaMemcpy(device_flat, host_flat, arraySize * sizeof(double), cudaMemcpyHostToDevice);
//
// //device props
// //show device information
// cudaGetDeviceCount(&deviceCount);
// std::cout << "\nDevice count: " << deviceCount << std::endl;
//
// //device property
// for (int p = 0; p < deviceCount; p++)
// {
// cudaDeviceProp deviceProp;
// cudaGetDeviceProperties(&deviceProp, p);
//
// std::cout << "Device number " << p << std::endl;
// std::cout << "\tDevice name " << deviceProp.name << std::endl;
// std::cout << "\tMax threads dim " << deviceProp.maxThreadsDim << std::endl;;
// std::cout << "\tMax grid size " << deviceProp.maxGridSize << std::endl;
// std::cout << "\tMax threads per blocks " << deviceProp.maxThreadsPerBlock << std::endl;
// std::cout << "\tShared memory per blocks " << deviceProp.sharedMemPerBlock << std::endl;
// std::cout << "\tWarp size " << deviceProp.warpSize << std::endl;
// std::cout << "\n";
// }
//
// //init set kernel
//
// //int blockInGrid = (arraySize + THREADS_IN_BLOCKS - 1) / THREADS_IN_BLOCKS;
// //int limitX = 100000;
// //int limitY = 100000;
// //int threadLimitPerBlock = 140;
// //int numberOfThreads = limitX * limitY;
// //int requiredNumberOfBlocks = (numberOfThreads / threadLimitPerBlock) + 1;
//
// //Kernnel block and grid
// dim3 Grid(1, 1, 1); //348
// dim3 ThreadsPerblock(1, 1, 1); //288 block width
//
// //kernel
// DarkMatterMaster <<< Grid, ThreadsPerblock >>> (arraySize, device_real, device_flat, device_resultDD, device_resultDR, device_resultRR);
// cudaDeviceSynchronize();
// //error check
// cudaError_t err = cudaGetLastError();
// if (err != cudaSuccess)
// {
// std::cout << "Error in the kernel " << cudaGetErrorString(err) << std::endl;
// return -1;
// }
//
// //copy back the histogram array
// cudaMemcpy(host_resultDD, device_resultDD, HISTOGRAM_DEGREE * sizeof(double), cudaMemcpyDeviceToHost);
// cudaMemcpy(host_resultDR, device_resultDR, HISTOGRAM_DEGREE * sizeof(double), cudaMemcpyDeviceToHost);
// cudaMemcpy(host_resultRR, device_resultRR, HISTOGRAM_DEGREE * sizeof(double), cudaMemcpyDeviceToHost);
// //debug
//
// for (int i = 0; i < HISTOGRAM_DEGREE; i++)
// {
// std:cout << "hist DD=> " << i << " is " << host_resultDD[i] << std::endl;
// }
// //free c++ memory
// std::cout << "Now frre the C++ memory\n" << std::endl;
// delete[] host_flat;
// delete[] host_real;
// delete[] host_resultDD;
// delete[] host_resultDR;
// delete[] host_resultRR;
//
// //free cuda memory
// std::cout << "Now frre the Cuda memory\n" << std::endl;
// cudaFree(device_real);
// cudaFree(device_flat);
// cudaFree(device_resultDD);
// cudaFree(device_resultDR);
// cudaFree(device_resultRR);
//
// //end clock
// clock_t masterEnd = clock();
// float elapsed = (float)(masterEnd - masterStart) / CLOCKS_PER_SEC;
// std::cout << "End procees in " << elapsed << " secs" << std::endl;
//
//
// return EXIT_SUCCESS;
//} |
10,294 | #include "includes.h"
__global__ void SubtractMulti(float *d_Result, float *d_Data, int width, int pitch, int height)
{
const int x = blockIdx.x*SUBTRACTM_W + threadIdx.x;
const int y = blockIdx.y*SUBTRACTM_H + threadIdx.y;
int sz = height*pitch;
int p = threadIdx.z*sz + y*pitch + x;
if (x<width && y<height)
d_Result[p] = d_Data[p] - d_Data[p + sz];
__syncthreads();
} |
10,295 | #include "includes.h"
/*
*
* Carlos Roman Rivera - A01700820
*
* Programming Languages - Cuda Quiz
*
*/
#define N 9
#define K N/3
#define ThreadsPerBlock K
#define NumBlocks K
__global__ void compress(float *mat, int n, float *comp, int k){
int row = threadIdx.y + blockIdx.y * blockDim.y;
int col = threadIdx.x + blockIdx.x * blockDim.x;
if (row < k && col < k) {
comp[col + row * k] = 0;
for (int i_row = 0 ; i_row < k ; i_row++) {
for (int j_col = 0 ; j_col < k ; j_col++) {
comp[col + row * k] += mat[(col + j_col) + (row + i_row) * n];
}
}
}
} |
10,296 | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "cuda_runtime.h"
extern "C" {
int cuda_set_device(int i_gpu)
{
cudaError_t err = cudaSetDevice(i_gpu);
if (err != cudaSuccess)
{
printf("\n Error in cudaSetDevice: %s \n", cudaGetErrorString(err));
exit(1);
}
return 0;
}
int cuda_get_device_count(int *n_gpu)
{
cudaError_t err = cudaGetDeviceCount(n_gpu);
if (err != cudaSuccess)
{
printf("\n Error in cudaGetDeviceCount: %s \n", cudaGetErrorString(err));
exit(1);
}
return 0;
}
int cuda_device_synchronize()
{
cudaError_t err = cudaDeviceSynchronize();
if (err != cudaSuccess)
{
printf("\n Error in cudaDeviceSynchronize: %s \n", cudaGetErrorString(err));
}
return 0;
}
int cuda_malloc(intptr_t *a, size_t size)
{
cudaError_t err = cudaMalloc((void **) a, size);
if (err != cudaSuccess)
{
printf("\n Error in cudaMalloc: %s \n", cudaGetErrorString(err));
exit(1);
}
return 0;
}
int cuda_free(intptr_t *a)
{
cudaError_t err = cudaFree(a);
if (err != cudaSuccess)
{
printf("\n Error in cudaFree: %s \n", cudaGetErrorString(err));
exit(1);
}
return 0;
}
int cuda_memcpy(intptr_t *dest, intptr_t *src, size_t count, int dir)
{
cudaMemcpyKind dir2;
switch (dir)
{
case 0:
dir2 = cudaMemcpyHostToDevice;
break;
case 1:
dir2 = cudaMemcpyDeviceToHost;
break;
case 2:
dir2 = cudaMemcpyDeviceToDevice;
break;
}
cudaError_t err = cudaMemcpy(dest, src, count, dir2);
if (err != cudaSuccess)
{
printf("\n Error in cudaMemcpy: %s \n", cudaGetErrorString(err));
exit(1);
}
return 0;
}
}
|
10,297 | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
using std::cout;
using std::cin;
using std::fstream;
int dummy; // makes it work
#define BLOCK_SIZE_MULTIPLIER 16 // TODO: make ths dynamic as to not exceed 1024 blocks
#define CLAMP(x, a, b) ((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))
#define DIVCEIL(x, y) (((x) + (y) - 1) / (y)) // division that rounds up
__global__ void separateChannels(uchar4 *inputRGBA,
int *_x_dim,
int *_y_dim,
unsigned char *r,
unsigned char *g,
unsigned char *b)
{
int x_dim = *_x_dim;
int y_dim = *_y_dim;
int i = threadIdx.x + blockDim.x * blockIdx.x + (threadIdx.y + blockDim.y * blockIdx.y) * x_dim;
if (i >= x_dim * y_dim) {
return; // value out of bounds, don't do anything
}
uchar4 tmp = inputRGBA[i];
r[i] = (unsigned char)tmp.x;
g[i] = (unsigned char)tmp.y;
b[i] = (unsigned char)tmp.z;
}
__global__ void recombineChannels(unsigned char *r,
unsigned char *g,
unsigned char *b,
int *_x_dim,
int *_y_dim,
uchar4 *outputRGBA)
{
int x_dim = *_x_dim;
int y_dim = *_y_dim;
int i = threadIdx.x + blockDim.x * blockIdx.x + (threadIdx.y + blockDim.y * blockIdx.y) * x_dim;
if (i >= x_dim * y_dim) {
return;
}
uchar4 tmp;
tmp.x = r[i];
tmp.y = g[i];
tmp.z = b[i];
tmp.w = 255; // no transparency
outputRGBA[i] = tmp;
}
__global__ void gaussianBlur(unsigned char *in,
float *filter,
int *_filter_dim,
int *_x_dim,
int *_y_dim,
unsigned char *out)
{
int filter_dim = *_filter_dim;
int x_dim = *_x_dim;
int y_dim = *_y_dim;
int x_pos = blockIdx.x * blockDim.x + threadIdx.x;
int y_pos = blockIdx.y * blockDim.y + threadIdx.y;
if (x_pos >= x_dim || y_pos >= y_dim) {
return; // out of bounds
}
float val = 0.0f;
int x_i_pos, y_i_pos, offset = filter_dim / 2;
for (int x_i = 0; x_i < filter_dim; x_i++) {
for (int y_i = 0; y_i < filter_dim; y_i++) {
// multiply each value in the adjacent pixels clamped to the edges
// of the image by the corresponding filter value and add it to the
// total value that will be set in the blurred image
x_i_pos = x_i + x_pos - offset;
y_i_pos = y_i + y_pos - offset;
val += float(in[CLAMP(x_i_pos, 0, x_dim - 1) +
CLAMP(y_i_pos, 0, y_dim - 1) * x_dim]) *
filter[x_i + y_i * filter_dim];
}
}
out[x_pos + y_pos * x_dim] = (unsigned char)val;
}
int main()
{
// initialize, allocate and read relevant host image variables
int h_x_dim, h_y_dim;
uchar4 *h_img;
fstream h_img_stream_in;
h_img_stream_in.open("test.ppm", fstream::in);
h_img_stream_in.ignore(2, EOF); // ignores the P3 at the beginning of the file
h_img_stream_in >> h_x_dim >> h_y_dim;
h_img_stream_in >> dummy;
int h_xy_dim = h_x_dim * h_y_dim;
h_img = (uchar4 *) malloc(h_xy_dim * sizeof(uchar4));
int x, y, z;
for (int i = 0; i < h_xy_dim; i++) {
h_img_stream_in >> x >> y >> z;
h_img[i].x = (unsigned char)x;
h_img[i].y = (unsigned char)y;
h_img[i].z = (unsigned char)z;
h_img[i].w = 255;
}
h_img_stream_in.close();
cout<<"file loaded\n";
// initialize, allocate and read relevant host filter variables
int h_filter_dim;
float *h_filter;
fstream h_filter_stream_in;
h_filter_stream_in.open("filter", fstream::in);
h_filter_stream_in >> h_filter_dim;
int h_filter_dim2 = h_filter_dim * h_filter_dim;
h_filter = (float *) malloc(h_filter_dim2 * sizeof(float));
for (int i = 0; i < h_filter_dim2; i++) {
h_filter_stream_in >> h_filter[i];
}
h_filter_stream_in.close();
cout<<"filter loaded\n";
// initialie and allocate relevant device variables
uchar4 *d_img_in, *d_img_out;
unsigned char *d_img_r_in, *d_img_g_in, *d_img_b_in;
unsigned char *d_img_r_out, *d_img_g_out, *d_img_b_out;
int *d_x_dim, *d_y_dim;
float *d_filter;
int *d_filter_dim;
cudaMalloc((void **) &d_img_in, h_xy_dim * sizeof(uchar4));
cudaMalloc((void **) &d_img_out, h_xy_dim * sizeof(uchar4));
cudaMalloc((void **) &d_img_r_in, h_xy_dim * sizeof(unsigned char));
cudaMalloc((void **) &d_img_g_in, h_xy_dim * sizeof(unsigned char));
cudaMalloc((void **) &d_img_b_in, h_xy_dim * sizeof(unsigned char));
cudaMalloc((void **) &d_img_r_out, h_xy_dim * sizeof(unsigned char));
cudaMalloc((void **) &d_img_g_out, h_xy_dim * sizeof(unsigned char));
cudaMalloc((void **) &d_img_b_out, h_xy_dim * sizeof(unsigned char));
cudaMalloc((void **) &d_x_dim, sizeof(int));
cudaMalloc((void **) &d_y_dim, sizeof(int));
cudaMalloc((void **) &d_filter, h_filter_dim2 * sizeof(float));
cudaMalloc((void **) &d_filter_dim, sizeof(int));
cudaMemcpy(d_img_in, h_img, h_xy_dim * sizeof(uchar4), cudaMemcpyHostToDevice);
cudaMemcpy(d_x_dim, &h_x_dim, sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_y_dim, &h_y_dim, sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_filter, h_filter, h_filter_dim2 * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_filter_dim, &h_filter_dim, sizeof(int), cudaMemcpyHostToDevice);
// determine appropriate block dimensions and numbers
dim3 block_dim = dim3(h_filter_dim * BLOCK_SIZE_MULTIPLIER,
h_filter_dim * BLOCK_SIZE_MULTIPLIER, 1);
dim3 block_number = dim3(DIVCEIL(h_x_dim, block_dim.x),
DIVCEIL(h_y_dim, block_dim.y), 1);
cout<<"memory copied\n";
cout << "dummy input: ";
cin>>dummy;
cout<<"starting operations\n";
// perform operations on GPU
separateChannels<<<block_dim, block_number>>>
(d_img_in, d_x_dim, d_y_dim, d_img_r_in, d_img_g_in, d_img_b_in);
cout<<"channels separated\n";
gaussianBlur<<<block_dim, block_number>>>
(d_img_r_in, d_filter, d_filter_dim, d_x_dim, d_y_dim, d_img_r_out);
cout<<"red blurred\n";
gaussianBlur<<<block_dim, block_number>>>
(d_img_g_in, d_filter, d_filter_dim, d_x_dim, d_y_dim, d_img_g_out);
cout<<"green blurred\n";
gaussianBlur<<<block_dim, block_number>>>
(d_img_b_in, d_filter, d_filter_dim, d_x_dim, d_y_dim, d_img_b_out);
cout<<"blue blurred\n";
recombineChannels<<<block_dim, block_number>>>
(d_img_r_out, d_img_g_out, d_img_b_out, d_x_dim, d_y_dim, d_img_out);
cout<<"channels recombined\n";
cout<<"operations done\n";
// copy data back from GPU and print it to file
cudaMemcpy(h_img, d_img_out, h_xy_dim * sizeof(uchar4), cudaMemcpyDeviceToHost);
fstream h_img_stream_out;
h_img_stream_out.open("blurred.ppm", fstream::out);
h_img_stream_out << "P3 " << h_x_dim << " " << h_y_dim << "\n255\n";
for (int i = 0; i < h_xy_dim; i++) {
h_img_stream_out << (int)h_img[i].x << " " << (int)h_img[i].y << " " << (int)h_img[i].z << "\n";
}
h_img_stream_out.close();
cout<<"output written\n";
// free memory and exit
free(h_img);
free(h_filter);
cudaFree(d_img_in);
cudaFree(d_img_out);
cudaFree(d_img_r_in);
cudaFree(d_img_g_in);
cudaFree(d_img_b_in);
cudaFree(d_img_r_out);
cudaFree(d_img_g_out);
cudaFree(d_img_b_out);
cudaFree(d_x_dim);
cudaFree(d_y_dim);
cudaFree(d_filter);
cudaFree(d_filter_dim);
cout<<"ALL DONE.\n";
return 0;
}
|
10,298 | #include <stdio.h>
__global__ void kernelA(int N){
int globalThreadId = blockIdx.x * blockDim.x + threadIdx.x;
// Conditional statement to exit if index (globalThreadId) is out of bounds
if(globalThreadId >= N) {
return;
}
//Insert code here
printf("Hello from block %d, threadInd x %d,threadInd y %d,threadInd z %d ,blockDim x %d, blockDim y %d,blockDim z %d \n", blockIdx.x, threadIdx.x,threadIdx.y,threadIdx.z,blockDim.x,blockDim.y,blockDim.z );
}
int main()
{
// More realistic GPU problem size
int problemSize = 4; // try with 1000 or 100000000
//set the device on which the host execute files
cudaSetDevice(0);
// On average a good thread count, the best thread count varies based on the situation
int threadCount = 2; // try with 256 which is the averagely good size
// Simple way to ensure enough threads are launched
// may result in launching more threads than needed though
int blockCount = ceil(problemSize/threadCount);
kernelA <<<blockCount, threadCount>>>(problemSize);
cudaDeviceSynchronize();
cudaDeviceReset();
return 0;
}
|
10,299 | #include "includes.h"
__global__ void g_getSoftMaxP(float* softMaxP, float* b, int cols, int row){
int bid = blockIdx.x;
extern __shared__ float _share[];
float * _max = _share;
float * _sum = _share + blockDim.x;
float* sp = softMaxP + bid;
_sum[threadIdx.x] = 0.0;
_max[threadIdx.x] = -100000000.0;
for(int tid = threadIdx.x * cols + blockIdx.x; tid < row * cols; tid += cols){
//int id = tid + threadIdx.x;
//if(id < cols){
sp[tid] += b[tid];
_max[threadIdx.x] = max(_max[threadIdx.x], sp[tid]);
//}
}
__syncthreads();
int len = blockDim.x;
while(len != 1)
{
__syncthreads();
int skip = (len + 1) >> 1;
if(threadIdx.x < (len >> 1))
{
if(_max[threadIdx.x] < _max[threadIdx.x + skip])
{
_max[threadIdx.x] = _max[threadIdx.x + skip];
}
}
len = (len + 1) >> 1;
}
__syncthreads();
for(int tid = threadIdx.x * cols + blockIdx.x; tid < row * cols; tid += cols){
// int id = tid + threadIdx.x;
//if(id < cols){
sp[tid] -= _max[0];
sp[tid] = __expf(sp[tid]);
_sum[threadIdx.x] += sp[tid];
//}
}
__syncthreads();
len = blockDim.x;
while(len != 1)
{
__syncthreads();
int skip = (len + 1) >> 1;
if(threadIdx.x < (len >> 1))
{
_sum[threadIdx.x] += _sum[threadIdx.x + skip];
}
len = (len + 1) >> 1;
}
__syncthreads();
for(int tid = threadIdx.x * cols + blockIdx.x; tid < row * cols; tid += cols){
//int id = tid + threadIdx.x;
//if(id < cols){
sp[tid] /= _sum[0];
//}
}
} |
10,300 | #include <iostream>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <vector>
#include <functional>
__global__ void add(int* in, int* out) {
int idx = threadIdx.x;
int f = in[idx];
out[idx] = f * f;
}
int main(int argc, char* argv[]) {
std::vector<int> dd(512);
std::iota(std::begin(dd), std::end(dd), 1);
auto sz = 512 * sizeof(int);
int* din = 0;
int* dout = 0;
cudaMalloc( (void**)&din, sz );
cudaMalloc( (void**)&dout, sz );
cudaMemcpy(din, &(dd.data()[0]), sz, cudaMemcpyHostToDevice);
add<<<1, 512>>>(din, dout);
std::vector<int> oo(512, 0);
cudaMemcpy(&(oo.data()[0]), dout, sz, cudaMemcpyDeviceToHost);
cudaFree( din );
cudaFree( dout );
std::copy(std::begin(oo), std::end(oo), std::ostream_iterator<int>(std::cout, " "));
std::cout << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.