serial_no int64 1 24.2k | cuda_source stringlengths 11 9.01M |
|---|---|
2,701 | #include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <math.h>
#include <sys/time.h>
#include <cuda.h>
double wtime(void)
{
static struct timeval tv0;
double time_;
gettimeofday(&tv0,(struct timezone*)0);
time_=(double)((tv0.tv_usec + (tv0.tv_sec)*1000000));
return( time_/1000000);
}
void matrixMulCPU(float *A, float *B, int hA, int wA, int wB, float *C)
{
int i,j,k;
for (i=0; i<hA; i++)
for (j=0; j<wB; j++){
C[i*wB+j] = 0.0;
for (k=0; k<wA; k++)
C[i*wB+j] += A[i*wA+k]*B[k*wB+j];
}
}
__global__ void matrixMultGPU(float* a, float* b, float* c, int nColsA,
int nRowsC, int nColsC){
int row = blockIdx.y * blockDim.y + threadIdx.y;
int col = blockIdx.x * blockDim.x + threadIdx.x;
if(row < nRowsC && col < nColsC){
for(int i = 0; i < nColsA; ++i){
//In b[], nColsA = nRowsB
c[row * nColsC + col] += a[row * nColsA + i] * b[i * nColsA + col];
}
}
}
void init_matrix(float *M, int hM, int wM, float k)
{
int i,j;
for (i=0; i<hM; i++)
for (j=0; j<wM; j++)
if (i==j)
M[i*wM+j] = k*1.0f;
else
M[i*wM+j] = -1.0f/(float)(wM);
}
void print_matrix(float *M, int hM, int wM)
{
int i,j;
for (i=0; i<hM; i++){
// printf("Line %i: ", i);
for (j=0; j<wM; j++)
printf("%4.1f ", M[i*wM+j]);
printf("\n");
}
}
int diff(float *A, float *B, int hA, int wA, int wB, float *C_gpu)
{
float *C_cpu;
int size_C = wB * hA;
C_cpu = (float*)malloc(size_C*sizeof(float));
int i,j,k;
for (i=0; i<hA; i++)
for (j=0; j<wB; j++){
C_cpu[i*wB+j] = 0.0;
for (k=0; k<wA; k++){
C_cpu[i*wB+j] += A[i*wA+k]*B[k*wB+j];
}
}
//printf("\n\nMATRIX C_cpu\n");print_matrix(C_cpu, hA, wB);
for (i=0; i<hA; i++)
for (j=0; j<wB; j++)
if (fabsf(C_cpu[i*wB+j]-C_gpu[i*wB+j])>1e-5)
{
printf("[%i,%i]: %f!=%f\n", i, j, C_cpu[i*wB+j], C_gpu[i*wB+j]);
return(0);
}
return(1);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char** argv)
{
// Matrix variables
float *A, *B, *C;
float *a_GPU, *b_GPU, *c_GPU, *gpu_c_host;
int hA, wA, hB, wB;
double t0, t1;
int i;
setbuf(stdout, NULL);
if (argc!=4){
printf("./exec hA hB/WA wB\n");
exit(-1);
}
hA = atoi(argv[1]);
hB = wA = atoi(argv[2]);
wB = atoi(argv[3]);
//init matrix sizes
int size_A = wA * hA;
int size_B = wB * hB;
int size_C = wB * hA;
// CPU Init A and B, malloc C
A = (float*)malloc(size_A*sizeof(float));
init_matrix(A, hA, wA, 1.0);
B = (float*)malloc(size_B*sizeof(float));
init_matrix(B, hB, wB, 2.0);
C = (float*)malloc(size_B*sizeof(float));
for (i = 0; i < (hA*wB); i++) {
C[i] = 0.0;
}
//GPU malloc A,B and C
cudaMalloc((void **)&a_GPU, size_A * sizeof(float));
cudaMalloc((void **)&b_GPU, size_B * sizeof(float));
cudaMalloc((void **)&c_GPU, size_C * sizeof(float));
//CPU -> GPU
cudaMemcpy(a_GPU,A,size_A * sizeof(float),cudaMemcpyHostToDevice);
cudaMemcpy(b_GPU,B,size_B * sizeof(float),cudaMemcpyHostToDevice);
cudaMemcpy(c_GPU,C,size_C * sizeof(float),cudaMemcpyHostToDevice);
//GPU Grid and Block ini
//Define BlockSize
dim3 dimBlock(16,16);
//Define grid size
//What happend if C's matrix size it's a prime number?
int grid_x_size = ceil((float)wB / 16);
int grid_y_size = ceil((float)hA / 16);
printf("grid_x_size = %i, grid_y_size = %i\n",grid_x_size, grid_y_size);
dim3 dimGrid(grid_x_size, grid_y_size);
//Start GPU timer
t0 = wtime();
//Invoque kernel
matrixMultGPU<<<dimGrid,dimBlock>>>(a_GPU, b_GPU, c_GPU, wA, hA, wB);
//Wait for the kernel
cudaThreadSynchronize();
//Stop timer and print value
t1 = wtime(); printf("Time GPU=%f\n", t1-t0);
//GPU result to host
gpu_c_host = (float *)malloc(size_C * sizeof(float));
cudaMemcpy(gpu_c_host,c_GPU,size_C * sizeof(float),cudaMemcpyDeviceToHost);
if (!diff(A, B, hA, wA, wB, gpu_c_host)){
printf("ERROR=GPU.vs.CPU matrix mult differs\n");
}
else{
printf("GPU.vs.CPU matrix is equal! :D\n");
}
// print Matrix
//printf("\n\nMATRIX A\n");print_matrix(A, hA, wA);
//printf("\n\nMATRIX B\n");print_matrix(B, hB, wB);
//printf("\n\nGPU C\n");print_matrix(gpu_c_host, hA, wB);
/* Free CPU */
free(A);
free(B);
free(gpu_c_host);
/* Free GPU */
cudaFree(a_GPU);
cudaFree(b_GPU);
cudaFree(c_GPU);
return (1);
}
|
2,702 | #include <cuda.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define M 512
#define N 512
#define TILE_DIM 32
__global__ void TiledMatMul(int *A, int *B, int *C)
{
__shared__ float tiled_A[TILE_DIM][TILE_DIM];
__shared__ float tiled_B[TILE_DIM][TILE_DIM];
int bx = blockIdx.x;
int by = blockIdx.y;
int tx = threadIdx.x;
int ty = threadIdx.y;
int row = by * blockDim.y + ty;
int col = bx * blockDim.x + tx;
int cVal = 0;
for (int t = 0; t < (M - 1) / TILE_DIM + 1; ++t)
{
if (row < M && (t * TILE_DIM + tx) < N)
tiled_A[ty][tx] = A[row * N + t * TILE_DIM + tx];
else
tiled_A[ty][tx] = 0;
if ((t * TILE_DIM + ty) < N && col < M)
tiled_B[ty][tx] = B[(t * TILE_DIM + ty) * M + col];
else
tiled_B[ty][tx] = 0;
__syncthreads();
for (int i = 0; i < TILE_DIM; ++i)
cVal += (tiled_A[ty][i] * tiled_B[i][tx]);
__syncthreads();
if (row < M && col < M)
C[row * M + col] = cVal;
}
}
void CPUMatMul(int A[M][N], int B[N][M], int C[M][M])
{
for (int row = 0; row < M; ++row)
{
for (int col = 0; col < M; ++col)
{
int prod_val = 0;
for (int k = 0; k < N; ++k)
{
prod_val = prod_val + (A[row][k] * B[k][col]);
}
C[row][col] = prod_val;
}
}
}
bool compare(int A[M][M], int B[M][M], double accuracy)
{
for (int i = 0; i < M; ++i)
{
for (int j = 0; j < M; ++j)
if ((abs(A[i][j] - B[i][j])) > accuracy)
return 0;
}
return 1;
}
int main()
{
int *A, *B, *C;
int host_A[M][N], host_B[N][M], host_C[M][M], CPUMatMulAns[M][M];
int i, j;
for (i = 0; i < M; ++i)
{
for (j = 0; j < N; ++j)
host_A[i][j] = rand()%100;
}
for (i = 0; i < N; ++i)
{
for (j = 0; j < M; ++j)
host_B[i][j] = rand()%100;
}
CPUMatMul(host_A, host_B, CPUMatMulAns);
cudaMalloc((void **)&A, M * N * sizeof(int));
cudaMalloc((void **)&B, M * N * sizeof(int));
cudaMalloc((void **)&C, M * M * sizeof(int));
cudaMemcpy(A, host_A, M * N * sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(B, host_B, M * N * sizeof(int), cudaMemcpyHostToDevice);
dim3 blockDim(TILE_DIM, TILE_DIM, 1);
dim3 gridDim((int)ceil((float)(M) / blockDim.x), (float)ceil((int)(N) / blockDim.y), 1);
TiledMatMul<<<gridDim, blockDim>>>(A, B, C);
cudaDeviceSynchronize();
cudaMemcpy(host_C, C, M * M * sizeof(int), cudaMemcpyDeviceToHost);
double accuracy = pow(10, -1);
if (compare(CPUMatMulAns, host_C, accuracy))
printf("Execution Succesfull\n The answers generated by GPU and CPU are equal\n");
else
printf("Execution Succesfull\n The answers generated by GPU and CPU are equal\n");
cudaFree(A);
cudaFree(B);
cudaFree(C);
return 0;
}
|
2,703 | #include<stdio.h>
#include<stdlib.h>
#include<cuda.h>
//#define m 5
//#define p 5
//#define n 5
__global__ void devicematrix(int *d_m1, int *d_m2, int *d_op, int m, int p, int n)
{
int i = blockIdx.x * blockDim.x + threadIdx.x;
int j = blockIdx.y * blockDim.y + threadIdx.y;
int k;
if(i<m && j<n)
{
int res = 22;
for(k=0;k<p;k++)
{
int m1ele = d_m1[i*p + k];
int m2ele = d_m2[k*n + j];
res = res + (m1ele * m2ele);
}
d_op[i*n + j] = res;
}
}
void hostmatrix(int *h_m1, int *h_m2, int *h_op, int m, int p, int n)
{
int *d_m1;
int *d_m2;
int *d_op;
cudaMalloc((void **)&d_m1,(m*p)*sizeof(int));
cudaMalloc((void **)&d_m2,(p*n)*sizeof(int));
cudaMalloc((void **)&d_op,(m*n)*sizeof(int));
cudaMemcpy(d_m1, h_m1, (m*p)*sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_m2, h_m2, (p*n)*sizeof(int), cudaMemcpyHostToDevice);
int i,j;
/*for(i=0;i<m;i++)
{ for(j=0;j<p;j++)
{ printf("%d " ,h_m1[i*p + j]);
}
printf("\n");
} */
dim3 gridDim(1,1,1);
dim3 blockDim(5,5,1);
devicematrix<<<gridDim,blockDim>>>(d_m1,d_m2,d_op,m,p,n);
cudaMemcpy(h_op, d_op, (m*n)*sizeof(int), cudaMemcpyDeviceToHost);
cudaFree(d_m1);
cudaFree(d_m2);
cudaFree(d_op);
}
int main()
{
int i,j,l=1;
int m=5;
int n=5;
int p=5;
int *h_m1 = (int *)malloc((m*p)*sizeof(int));
int *h_m2 = (int *)malloc((p*n)*sizeof(int));
int *h_op = (int *)malloc((m*n)*sizeof(int));
printf("hello world");
for(i=0;i<m;i++)
{
for(j=0;j<p;j++)
{
h_m1[i*p + j] = l;
l++;
}
}
for(i=0;i<p;i++)
{
for(j=0;j<n;j++)
{
h_m2[i*n + j] = l;
l++;
}
}
hostmatrix(h_m1,h_m2,h_op,m,p,n);
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
printf("%d ",h_op[i*n + j]);
}
printf("\n");
}
}
|
2,704 | /******************************************************************************
*cr
*cr (C) Copyright 2010 The Board of Trustees of the
*cr University of Illinois
*cr All Rights Reserved
*cr
******************************************************************************/
#include <stdio.h>
#define TILE_SZ 16
__global__ void Gelim(float *A, int numvar){/////////////add b back in middle
__shared__ float A_s[TILE_SZ][TILE_SZ];
int Tirow = threadIdx.y;
int Ticol = threadIdx.x;
A_s[Tirow][Ticol] = A[(Tirow * (numvar +1)) + Ticol];
for(int i = 1; i < numvar; i++){
if((Tirow +i) < (numvar)){
float multiplier = A_s[Tirow+i][i-1]/A_s[i-1][i-1];
if(Tirow <= Ticol+1){
A_s[Tirow+i][Ticol] -= (multiplier * A_s[i-1][Ticol]);
}
else{
A_s[Tirow+i][Ticol] = 0;
}
__syncthreads();
}
//__syncthreads();
}
A[Tirow *(numvar+1) +Ticol] = A_s[Tirow][Ticol];/////////////replace a with b
}
void basicGelim(float *A, int numvar){ ////////add b back in middle
dim3 block(numvar+1, numvar, 1);
dim3 grid(1,1,1);
Gelim<<<grid,block>>>(A,numvar);//////////b back in mid
}
/*void basicSgemm(char transa, char transb, int m, int n, int k, float alpha, const float *A, int lda, const float *B, int ldb, float beta, float *C, int ldc)
{
if ((transa != 'N') && (transa != 'n')) {
printf("unsupported value of 'transa'\n");
return;
}
if ((transb != 'N') && (transb != 'n')) {
printf("unsupported value of 'transb'\n");
return;
}
if ((alpha - 1.0f > 1e-10) || (alpha - 1.0f < -1e-10)) {
printf("unsupported value of alpha\n");
return;
}
if ((beta - 0.0f > 1e-10) || (beta - 0.0f < -1e-10)) {
printf("unsupported value of beta\n");
return;
}*/
// Initialize thread block and kernel grid dimensions ---------------------
/* const unsigned int BLOCK_SIZE = TILE_SZ;
dim3 block(BLOCK_SIZE,BLOCK_SIZE);
dim3 grid((n+BLOCK_SIZE-1)/BLOCK_SIZE,(m+BLOCK_SIZE-1)/BLOCK_SIZE);
//INSERT CODE HERE
// Invoke CUDA kernel -----------------------------------------------------
mysgemm<<<grid,block>>>(m,n,k,A,B,C);
//INSERT CODE HERE
dim3 block(numvar+1,numvar,1);
dim3 grid(1,1,1);
}*/
|
2,705 | #include <stdio.h>
#define N 32
__global__ void kernel(int* input, int* output){
for(int i=0; i<N; i++)
output[i] = 2 * input[i];
}
int main(void){
int *h_input, *h_output;
int *d_input, *d_output;
h_input = (int*)malloc(N*sizeof(int));
h_output = (int*)malloc(N*sizeof(int));
cudaMalloc((void**)&d_input, N*sizeof(int));
cudaMalloc((void**)&d_output, N*sizeof(int));
for(int i=0; i<N; i++) h_input[i] = i+1;
cudaMemcpy(d_input, h_input, N*sizeof(int), cudaMemcpyHostToDevice);
kernel<<<1, 1>>> (d_input, d_output);
cudaDeviceSynchronize();
cudaMemcpy(h_output, d_output, N*sizeof(int), cudaMemcpyDeviceToHost);
for(int i=0; i<N; i++) printf("%d -> %d\n", h_input[i], h_output[i]);
free(h_input);
free(h_output);
cudaFree(d_input);
cudaFree(d_output);
return 0;
} |
2,706 | #include <stdio.h>
#include <time.h>
#include <cuda.h>
#include <curand_kernel.h>
#define CL 2000000LL
// kernel
__global__ void picuda(double *res, long long W, curandState *states) {
long long i = blockIdx.x*blockDim.x + threadIdx.x;
if (i < W) {
double ans = 0;
unsigned int seed = (unsigned int) (clock() * i);
curand_init(seed, 0, 0, states + i);
for (long long j = 0; j < CL; ++j) {
//curandState s; // seed a random number generator
double x = curand_uniform_double(states + i);
double y = curand_uniform_double(states + i);
double bound = 1.0;
ans += ((x*x + y*y) <= bound) ? 1 : 0;
}
res[i] = 4.0 * ans / (double) CL;
}
}
int main(void) {
double *res_h; // pointers to host memory
double *res_d; // pointer to device memory
cudaError_t err;
const long long W = 64048LL;
size_t size = W*sizeof(double);
res_h = (double *)malloc(size);
err = cudaMalloc((void **) &res_d, size);
if (err != cudaSuccess)
fprintf(stderr,"Problemas solicitando memoria para res_d\n");
float blockSize = 1024;
dim3 dimBlock (ceil(W/blockSize), 1, 1);
dim3 dimGrid (blockSize, 1, 1);
curandState *devStates;
cudaMalloc( (void **)&devStates, W * sizeof(curandState) );
picuda <<< dimGrid, dimBlock >>> (res_d, W, devStates);
// Retrieve result from device and store in b_h
err = cudaMemcpy(res_h, res_d, size, cudaMemcpyDeviceToHost);
if (err != cudaSuccess)
fprintf(stderr,"Problemas copiando de device a host\n");
//print results
double ans = 0;
for (long long i = 0; i < W; ++i) {
ans += res_h[i];
}
printf("Pi's value : %.10lf\n", ans / W);
// cleanup
free(res_h);
cudaFree(res_d);
return 0;
}
|
2,707 | #include <math.h>
#include <stdio.h>
#include <cuda_runtime.h>
__global__ void kernel_add_sq(float* c, const float* a, const float* b, int N)
{
int i = threadIdx.x + blockDim.x * blockIdx.x;
if (i < N) {
c[i] = a[i] * a[i] + b[i] * b[i];
}
}
inline cudaError_t CHECK(cudaError_t err)
{
if (err != cudaSuccess) {
printf("Error: %d %s\n", err, cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
return err;
}
int main(int argc, char** argv)
{
const int N = 1024 * 1024;
const int block_size = 256;
int i;
int size = N * sizeof(float);
float* h_a = (float*)malloc(size);
float* h_b = (float*)malloc(size);
float* h_c = (float*)malloc(size);
for (i = 0; i < N; i++) {
h_a[i] = sin(i);
h_b[i] = cos(i);
}
float *d_a, *d_b, *d_c;
CHECK(cudaMalloc((void**)&d_a, size));
CHECK(cudaMalloc((void**)&d_b, size));
CHECK(cudaMalloc((void**)&d_c, size));
CHECK(cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice));
CHECK(cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice));
// assumes block_size devices N
kernel_add_sq<<<N / block_size, block_size>>>(d_c, d_a, d_b, N);
CHECK(cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost));
printf("=== sin(i) + cos(i)\n");
for (i = 0; i < N; i += N / 32) {
printf("%0.2f = %0.2f + %0.2f\n", h_c[i], h_a[i], h_b[i]);
}
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
free(h_a);
free(h_b);
free(h_c);
}
|
2,708 | // What happens :
// CPU -> Get Inputs from File -> Remove Character + Pre-processing
// -> Make an Instrcution Table ( Row , Column , Value to be added ) -> GPU
// GPU -> Use Atomics to Add Values
//
// time : < 0.1 sec for 980m
//
// Uses : CUDA : Unified Memory
// C++ : Vectors , Map , String Functions
//
// Kindly Check Comments in Line 151 , 152
// Include All Libraries
#include <bits/stdc++.h>
using namespace std;
// GPU Kernel to Do everything
__global__ void add(int n, int *x, int *y,int *val,int *database,int N)
{
unsigned long long int id = (blockIdx.x*blockDim.y+threadIdx.y)*blockDim.x + threadIdx.x;
if(id<n){
atomicAdd(&database[N*x[id]+y[id]-1],val[id]);
}
}
// Structure to Store ( Row , Column , Value to be added )
struct ins_tab{
int row;
int col;
int val;
};
int main(int argc, char** argv){
fstream file_input,file_output;
int *m,*n,*p;
int *database;
int *row,*col,*val;
// opening file_input
file_input.open(argv[1]);
// Allocate Unified Memory -- accessible from CPU or GPU
cudaMallocManaged(&m,sizeof(int));
cudaMallocManaged(&n,sizeof(int));
cudaMallocManaged(&p,sizeof(int));
// Get Value of M,N;
file_input>>m[0]>>n[0];
// Allocate Arrays for Database
cudaMallocManaged(&database,(m[0])*(n[0])*sizeof(int));
// Get Database Value;
for(int i=0;i<(*m)*(*n);i++){
file_input>>database[i];
}
//Get Instructions Values
file_input>>*p;
string inp[p[0]],temp;
getline(file_input,temp);
for(int i=0;i<*p;i++){
getline(file_input,inp[i]);
}
file_input.close();
// Generate Instruction Table
vector<ins_tab> tab;
// Recurse through the string;
// Tokenise String
//Loop through strings
for(int i=0;i<*p;i++){
// God Functions to save me so much time , Also the Reason why Python is <3
// Remove C , U and other strings
inp[i].erase(std::remove(inp[i].begin(), inp[i].end(), 'U'), inp[i].end());
inp[i].erase(std::remove(inp[i].begin(), inp[i].end(), 'C'), inp[i].end());
// Change + to 1 and - to 0
map<char, char> rs = { {'+', '1'}, {'-', '0'} }; char r;
replace_if(inp[i].begin(), inp[i].end(), [&](char c){ return (rs.find(c) != rs.end())&& (r = rs[c]); }, r);
// Returns first token
int t = inp[i].length();
// Declaring character array
char char_array[t + 1];
// copying the contents of the string to char array
strcpy(char_array, inp[i].c_str());
// Keep printing tokens while one of the delimiters present in str[].
char *token = strtok(char_array, " ");
vector<int> ps;
while (token != NULL)
{
string s = token;
ps.push_back(stoi(s));
token = strtok(NULL, " ");
}
// Currently having ps ( processed string )
// ps[0] = which column
// ps[1] = column value
// ps[2] = how many instruction
// Loop through Possible Rows
for(int j=0;j<m[0];j++){
int row_val = ps[1]; // column value
if(database[ps[0]-1+j*n[0]]==row_val){ // if column value matches in a row
// Row is j
// Loop through Instructions
for (int k=1;k<=ps[2];k++){
tab.push_back({j,ps[3*(k)],ps[3*k+2]? ps[3*k+1] : -1 * ps[3*k+1] });
}
}
}
}
// CPU - Do Instructions as per Instruction Table;
// int s = tab.size();
// for (int i=0;i<s;i++)
// {
// // Accessing structure members using their names.
// database[n[0]*tab[i].row+tab[i].col-1]+=tab[i].val;
// }
// Transfer instruction table to GPU
int s = tab.size();
cudaMallocManaged(&row,s*sizeof(int));
cudaMallocManaged(&col,s*sizeof(int));
cudaMallocManaged(&val,s*sizeof(int));
// Copy arrays
for (int i=0;i<s;i++)
{
row[i]=tab[i].row;
col[i]=tab[i].col;
val[i]=tab[i].val;
}
// GPU Code
// Launch kernel on elements on the GPU
int blockSize = 512;
int numBlocks = (s + blockSize - 1) / blockSize;
add<<<numBlocks, blockSize>>>(s, row, col,val,database,n[0]);
// Wait for GPU to finish before accessing on host
cudaDeviceSynchronize();
// Preare Output file
file_output.open(argv[2],ios::trunc|ios::out);
// Print Output
for(int i=0;i<(*m)*(*n);i++){
if(i!=0 && i%*n==0){
file_output<<"\n";
}
file_output<<database[i]<<" ";
}
// Added this because Downloading output.txt File and Doing diff my_output.txt output.txt
// Threw me an Error saying the output.txt had an Newline in the end.
file_output<<"\n";
// Close File
file_output.close();
return 0;
}
|
2,709 | #include <stdio.h>
#include <math.h>
#include <cuda.h>
#include<iostream>
using namespace std;
__global__ void mul(int *a, int n)
{
__shared__ int s[4];
int t = threadIdx.x;
s[t] = a[2*t]*a[2*t+1];
a[2*t]=s[t];
}
int main(void)
{
const int n = 8;
int a[n], d[n],ans;
int no,x,y;
cout <<"Enter your number" << endl;
cin>>no;
x=(no/10)*10;
y=no%10;
cout<<"x:"<<x<<" y:"<<y<<endl;
a[0]=a[1]=a[2]=a[4]=x;
a[3]=a[5]=a[6]=a[7]=y;
int *d_d;
cudaMalloc(&d_d, n * sizeof(int));
cudaMemcpy(d_d, a, n*sizeof(int), cudaMemcpyHostToDevice);
mul<<<1,n/2>>>(d_d, n/2);
cudaMemcpy(d, d_d, n*sizeof(int), cudaMemcpyDeviceToHost);
cudaFree(d_d);
ans=d[0]+d[2]+d[4]+d[6];
cout<<"The Square is:"<<ans;
return 0;
}
|
2,710 | #include "includes.h"
__global__ void threshold_one(float *vec, float *vec_thres, int *bin, const int k_bin, const int n)
{
unsigned int xIndex = blockDim.x * blockIdx.x + threadIdx.x;
// xIndex is a value from 1 to k from the vector ind
if ( (xIndex < n) & (bin[xIndex]<=k_bin) )
vec_thres[xIndex]=vec[xIndex];
} |
2,711 | #include<stdio.h>
#include<cuda.h>
#include<cuda_runtime_api.h>
#include<stdlib.h>
#define O_Tile_Width 3
#define Mask_width 3
#define width 5
#define Block_width (O_Tile_Width+(Mask_width-1))
#define Mask_radius (Mask_width/2)
__global__ void convolution_1D_tiled(float *N,float *M,float *P)
{
int index_out_x=blockIdx.x*O_Tile_Width+threadIdx.x;
int index_in_x=index_out_x-Mask_radius;
__shared__ float N_shared[Block_width];
float Pvalue=0.0;
//Load Data into shared Memory (into TILE)
if((index_in_x>=0)&&(index_in_x<width))
{
N_shared[threadIdx.x]=N[index_in_x];
}
else
{
N_shared[threadIdx.x]=0.0f;
}
__syncthreads();
//Calculate Convolution (Multiply TILE and Mask Arrays)
if(threadIdx.x<O_Tile_Width)
{
//Pvalue=0.0f;
for(int j=0;j<Mask_width;j++)
{
Pvalue+=M[j]*N_shared[j+threadIdx.x];
}
P[index_out_x]=Pvalue;
}
}
int main()
{
float * input;
float * Mask;
float * output;
float * device_input;
float * device_Mask;
float * device_output;
input=(float *)malloc(sizeof(float)*width);
Mask=(float *)malloc(sizeof(float)*Mask_width);
output=(float *)malloc(sizeof(float)*width);
for(int i=0;i<width;i++)
{
input[i]=1.0;
}
for(int i=0;i<Mask_width;i++)
{
Mask[i]=1.0;
}
printf("\nInput:\n");
for(int i=0;i<width;i++)
{
printf(" %0.2f\t",*(input+i));
}
printf("\nMask:\n");
for(int i=0;i<Mask_width;i++)
{
printf(" %0.2f\t",*(Mask+i));
}
cudaMalloc((void **)&device_input,sizeof(float)*width);
cudaMalloc((void **)&device_Mask,sizeof(float)*Mask_width);
cudaMalloc((void **)&device_output,sizeof(float)*width);
cudaMemcpy(device_input,input,sizeof(float)*width,cudaMemcpyHostToDevice);
cudaMemcpy(device_Mask,Mask,sizeof(float)*Mask_width,cudaMemcpyHostToDevice);
dim3 dimBlock(Block_width,1,1);
dim3 dimGrid((((width-1)/O_Tile_Width)+1),1,1);
convolution_1D_tiled<<<dimGrid,dimBlock>>>(device_input,device_Mask,device_output);
cudaMemcpy(output,device_output,sizeof(float)*width,cudaMemcpyDeviceToHost);
printf("\nOutput:\n");
for(int i=0;i<width;i++)
{
printf(" %0.2f\t",*(output+i));
}
cudaFree(device_input);
cudaFree(device_Mask);
cudaFree(device_output);
free(input);
free(Mask);
free(output);
printf("\n\nNumber of Blocks: %d ",dimGrid.x);
printf("\n\nNumber of Threads Per Block: %d ",dimBlock.x);
return 0;
}
|
2,712 |
// set the current Jx on each cell
__global__ void set_current(int ncells, float *Jx, float *Jy, float *Jz) {
int tid = threadIdx.x + blockIdx.x * blockDim.x;
while (tid < ncells) {
Jx[tid] = Jx[tid]/float(2.0);
Jy[tid] = Jy[tid]/float(2.0);
Jz[tid] = Jz[tid]/float(2.0);
tid += blockDim.x * gridDim.x;
}
}
|
2,713 | #include <iostream>
#include <stdio.h>
#include <cuda.h>
#include <time.h>
using namespace std;
// ----------------------------------------------------------------------------
#define checkLastError() { \
cudaError_t error = cudaGetLastError(); \
int id; \
cudaGetDevice(&id); \
if(error != cudaSuccess) { \
printf("Cuda failure error in file '%s' in line %i: '%s' at device %d \n", \
__FILE__,__LINE__, cudaGetErrorString(error), id); \
exit(EXIT_FAILURE); \
} \
}
// ----------------------------------------------------------------------------
__global__
void __convolution(float *src, float *dst, int dimx, int dimy, int dimz)
{
__shared__ float sharedMem[14][14][14];
int shared_index_1d, global_index_1d, index_1d;
// int2 shared_index_2d, global_index_2d, index_2d;
int3 shared_index_3d, global_index_3d, index_3d;
// Multi batch loading
int trial;
for(trial=0; trial <6; trial++)
{
shared_index_1d = threadIdx.z * blockDim.y * blockDim.x +
threadIdx.y * blockDim.x +
threadIdx.x +
blockDim.x * blockDim.y * blockDim.z * trial; // Next number of loading
shared_index_3d = make_int3((shared_index_1d % ((blockDim.y+2*3) * (blockDim.x+2*3))) % (blockDim.x+2*3),
(shared_index_1d % ((blockDim.y+2*3) * (blockDim.x+2*3))) / (blockDim.x+2*3),
(shared_index_1d / ((blockDim.y+2*3) * (blockDim.x+2*3))) );
global_index_3d = make_int3(blockIdx.x * blockDim.x + shared_index_3d.x - 3,
blockIdx.y * blockDim.y + shared_index_3d.y - 3,
blockIdx.z * blockDim.z + shared_index_3d.z - 3);
global_index_1d = global_index_3d.z * dimy * dimx +
global_index_3d.y * dimx +
global_index_3d.x;
if (shared_index_3d.z < (blockDim.z + 2*3))
{
if (global_index_3d.z >= 0 && global_index_3d.z < dimz &&
global_index_3d.y >= 0 && global_index_3d.y < dimy &&
global_index_3d.x >= 0 && global_index_3d.x < dimx )
sharedMem[shared_index_3d.z][shared_index_3d.y][shared_index_3d.x] = src[global_index_1d];
else
sharedMem[shared_index_3d.z][shared_index_3d.y][shared_index_3d.x] = -1;
}
__syncthreads();
}
// // First batch loading
// shared_index_1d = threadIdx.z * blockDim.y * blockDim.x +
// threadIdx.y * blockDim.x +
// threadIdx.x;
// shared_index_3d = make_int3((shared_index_1d % ((blockDim.y+2*3) * (blockDim.x+2*3))) % (blockDim.x+2*3),
// (shared_index_1d % ((blockDim.y+2*3) * (blockDim.x+2*3))) / (blockDim.x+2*3),
// (shared_index_1d / ((blockDim.y+2*3) * (blockDim.x+2*3))) );
// global_index_3d = make_int3(blockIdx.x * blockDim.x + shared_index_3d.x - 3,
// blockIdx.y * blockDim.y + shared_index_3d.y - 3,
// blockIdx.z * blockDim.z + shared_index_3d.z - 3);
// global_index_1d = global_index_3d.z * dimy * dimx +
// global_index_3d.y * dimx +
// global_index_3d.x;
// if (global_index_3d.z >= 0 && global_index_3d.z < dimz &&
// global_index_3d.y >= 0 && global_index_3d.y < dimy &&
// global_index_3d.x >= 0 && global_index_3d.x < dimx )
// sharedMem[shared_index_3d.z][shared_index_3d.y][shared_index_3d.x] = src[global_index_1d];
// else
// sharedMem[shared_index_3d.z][shared_index_3d.y][shared_index_3d.x] = -1;
// __syncthreads();
// // Second batch loading
// shared_index_1d = threadIdx.z * blockDim.y * blockDim.x +
// threadIdx.y * blockDim.x +
// threadIdx.x +
// blockDim.x * blockDim.y * blockDim.z; // Next number of loading
// shared_index_3d = make_int3((shared_index_1d % ((blockDim.y+2*3) * (blockDim.x+2*3))) % (blockDim.x+2*3),
// (shared_index_1d % ((blockDim.y+2*3) * (blockDim.x+2*3))) / (blockDim.x+2*3),
// (shared_index_1d / ((blockDim.y+2*3) * (blockDim.x+2*3))) );
// global_index_3d = make_int3(blockIdx.x * blockDim.x + shared_index_3d.x - 3,
// blockIdx.y * blockDim.y + shared_index_3d.y - 3,
// blockIdx.z * blockDim.z + shared_index_3d.z - 3);
// global_index_1d = global_index_3d.z * dimy * dimx +
// global_index_3d.y * dimx +
// global_index_3d.x;
// if (shared_index_3d.z < (blockDim.z + 2*3))
// {
// if (global_index_3d.z >= 0 && global_index_3d.z < dimz &&
// global_index_3d.y >= 0 && global_index_3d.y < dimy &&
// global_index_3d.x >= 0 && global_index_3d.x < dimx )
// sharedMem[shared_index_3d.z][shared_index_3d.y][shared_index_3d.x] = src[global_index_1d];
// else
// sharedMem[shared_index_3d.z][shared_index_3d.y][shared_index_3d.x] = -1;
// }
// __syncthreads();
index_3d = make_int3(blockIdx.x * blockDim.x + threadIdx.x,
blockIdx.y * blockDim.y + threadIdx.y,
blockIdx.z * blockDim.z + threadIdx.z);
index_1d = index_3d.z * dimy * dimx +
index_3d.y * dimx +
index_3d.x;
// Store back
if (index_3d.z < dimz &&
index_3d.y < dimy &&
index_3d.x < dimx)
dst[index_1d] = sharedMem[threadIdx.z+3][threadIdx.y+3][threadIdx.x+3];
}
void convolution(float *src, float *dst, int dimx, int dimy, int dimz)
{
dim3 numBlocks((dimx/8 + ((dimx%8)?1:0)),
(dimy/8 + ((dimy%8)?1:0)),
(dimz/8 + ((dimz%8)?1:0)));
dim3 numThreads(8, 8, 8);
__convolution<<<numBlocks, numThreads>>>(src, dst, dimx, dimy, dimz);
}
// ----------------------------------------------------------------------------
int main(int argc, char** argv)
{
srand(time(NULL)); // for random number generator
// Specify dimensions
const int dimx = 100;
const int dimy = 100;
const int dimz = 100;
const int total = dimx*dimy*dimz;
// Allocate host memory
float *h_src = new float[total];
float *h_dst = new float[total];
// Allocate device memory
float *d_src;
float *d_dst;
cudaMalloc((void**)&d_src, total*sizeof(float)); checkLastError();
cudaMalloc((void**)&d_dst, total*sizeof(float)); checkLastError();
// Initialize the image source
for(int z=0; z<dimz; z++)
{
for(int y=0; y<dimy; y++)
{
for(int x=0; x<dimx; x++)
{
h_src[z*dimy*dimx+y*dimx+x] = (float)rand();
}
}
}
// Transferring to the device memory
cudaMemcpy(d_src, h_src, total*sizeof(float), cudaMemcpyHostToDevice); checkLastError();
convolution(d_src, d_dst, dimx, dimy, dimz);
cudaMemcpy(h_dst, d_dst, total*sizeof(float), cudaMemcpyDeviceToHost); checkLastError();
// Verify the result
for(int z=0; z<dimz; z++)
{
for(int y=0; y<dimy; y++)
{
for(int x=0; x<dimx; x++)
{
if(h_src[z*dimy*dimx+y*dimx+x] != h_dst[z*dimy*dimx+y*dimx+x])
{
printf("Solution doesnot match at x: %d, y: %d, z: %d\n", x, y, z);
goto cleanup;
}
// else
// printf("Solution match at x: %d, y: %d, z: %d\n", x, y, z);
}
}
}
printf("Solution is correct.\n");
cleanup:
cudaFree(d_src);
cudaFree(d_dst);
free(h_src);
free(h_dst);
return 0;
}
|
2,714 | #include <iostream>
#include <cuda_runtime.h>
using std::cout;
using std::endl;
int main(){
int numDev;
cudaGetDeviceCount( &numDev );
for(int i = 0; i<numDev; ++i){
cudaDeviceProp properties;
cudaGetDeviceProperties(&properties, i);
cout << "Device #: " << i << endl;
cout << "Name: " << properties.name << endl;
cout << "Global Mem: " << properties.totalGlobalMem << endl;
cout << "sharedMemPerBlock: " << properties.sharedMemPerBlock << endl;
cout << "warpSize: " << properties.warpSize << endl;
cout << "maxThreadsPerBlock: " << properties.maxThreadsPerBlock << endl;
cout << "maxThreads X: " << properties.maxThreadsDim[0] << endl;
cout << "maxThreads Y: " << properties.maxThreadsDim[1] << endl;
cout << "maxThreads Z: " << properties.maxThreadsDim[2] << endl;
cout << "maxGridSize X: " << properties.maxGridSize[0] << endl;
cout << "maxGridSize Y: " << properties.maxGridSize[1] << endl;
cout << "maxGridSize Z: " << properties.maxGridSize[2] << endl;
cout << "clockrate: " << properties.clockRate << endl;
cout << "constMem: " << properties.totalConstMem << endl;
}
}
|
2,715 | /*
============================================================================
Name : mull_forward.cu
Author : Christophoros Bekos (mpekchri@auth.gr)
Version :
Copyright : @ copyright notice
Description : CUDA compute reciprocals
============================================================================
*/
#include <iostream>
#include <numeric>
#include <stdlib.h>
#include <stdio.h>
#define work_per_block 100
#define threads_per_warp 32
__device__ void sigmoid(float& z){
z = 1.0 / (1.0 + exp(-(z))) ;
}
__device__ void hadamard_product_small(float* sh_a, float* sh_b, float* sh_res,
int multiplier, int size) {
int thread_id = threadIdx.y * blockDim.x + threadIdx.x;
// start the computations
for (int i = thread_id * multiplier;
i < thread_id * multiplier + multiplier; i++) {
sh_res[i] = sh_b[i] * sh_a[i] * ((int)(i < size));
}
// result is stored in sh_b vector\
//done
}
__device__ void array_sum_small(float* sha, float& result,
int size, int start) {
int thread_id = threadIdx.y * blockDim.x + threadIdx.x;
// start the computations
for (int i = threads_per_warp; i < work_per_block; i = i * 2) {
// switch 1 : even warps add their's neighbors contents
switch ((int) floor(thread_id / (double) i) % 2) {
case 0:
// thread_id % i == even
// add the "more next vector"
sha[thread_id] = sha[thread_id]
+ sha[i + thread_id] * ((int)(start + thread_id + i < size));
break;
default:
// thread_id % i == odd
// do nothing
break;
}
__syncthreads();
// switch2 : odd warps clean up their content
switch ((int) floor(thread_id / (double) i) % 2) {
case 0:
// thread_id % i == even
// do nothing
break;
default:
// thread_id % i == odd
// clean up
sha[thread_id] = 0;
//__syncthreads();
break;
}
__syncthreads();
}
// loop ended, sha[0:threads_per_warp] got the sum
if (thread_id == 0) {
for (int i = 0; i < threads_per_warp; i++) {
result = result + sha[i];
sha[i] = 0;
}
}
}
__device__ void mull_feedforward_one_col(float* result, int rows, int cols,
float* matrix, float* vector, int multiplier,int size,float bias,float* sigm_der) {
int thread_id = threadIdx.y * blockDim.x + threadIdx.x;
int block_id = blockIdx.y * gridDim.x + blockIdx.x;
extern __shared__ float shared[];
float* temp = shared;
float* m = &temp[rows * multiplier ];
float* v = &m[rows * multiplier];
float* res = &v[rows * multiplier];
for (int i = thread_id * multiplier;
i < thread_id * multiplier + multiplier; i++) {
m[i] = matrix[i]*((i<size));
}
for (int i = thread_id * multiplier;
i < thread_id * multiplier + multiplier; i++) {
v[i] = vector[i]*((i<size));
}
for (int i = thread_id * multiplier;
i < thread_id * multiplier + multiplier; i++) {
res[i] = 0.0;
}
for (int i = thread_id * multiplier;
i < thread_id * multiplier + multiplier; i++) {
temp[i] = 0.0;
}
__syncthreads();
hadamard_product_small(m, v, temp, multiplier, size);
__syncthreads();
for (int i = multiplier-1; i >=0; i--) {
array_sum_small(&temp[i*work_per_block],res[0], size, (i * work_per_block));
__syncthreads();
}
if (thread_id == 0) {
float tmp = (res[thread_id] + bias);
sigmoid(tmp);
result[block_id] = tmp;
sigm_der[block_id] = tmp*(1-tmp);
}
}
__global__ void feedforward(float* result, int rows, int cols,
float* matrix, float* vector, int multiplier,int size,float* biases,float* sigm_der){
int block_id = blockIdx.y * gridDim.x + blockIdx.x;
mull_feedforward_one_col(result,rows,cols,&matrix[block_id*size],vector,multiplier,size,biases[block_id],sigm_der);
}
void initialize(float *data, unsigned size, float arg) {
for (unsigned i = 0; i < size; ++i) {
data[i] = arg;
}
}
float* mull_feedforward(int rows, int cols, float* matrix, float* vector);
void cpu_feedforward(float* a_old,int rows, int cols,float** a_new,float* w,float* b,float* sigm_der_result) ;
int main(void) {
int rows = 783;
int cols = 30;
float *w = new float[rows*cols];
float *a_old = new float[rows];
float *b = new float[cols];
float *res = new float[cols];
float* sigm_der_result = new float[cols];
float* sigm_der_gpu = new float[cols];
float *m, *v, *a_next,*sigm_der,*biases;
for(int i=0; i<rows; i++){
for(int j=0; j<cols; j++){
w[i*cols+j] = 1.0;
// printf("index is %d , v = %0.6f \n",i*cols+j,matrix[i*cols+j]);
}
}
initialize(a_old, rows, 2.0);
initialize(b, cols, 10.5);
cudaMalloc((void**) &m, sizeof(float) * (rows * cols));
cudaMalloc((void**) &v, sizeof(float) * rows);
cudaMalloc((void**) &a_next, sizeof(float) * cols);
cudaMalloc((void**) &sigm_der, sizeof(float) * cols);
cudaMalloc((void**) &biases, sizeof(float) * cols);
cudaMemcpy(m, w, sizeof(float) * (rows * cols), cudaMemcpyHostToDevice);
cudaMemcpy(v, a_old, sizeof(float) * rows, cudaMemcpyHostToDevice);
cudaMemcpy(biases, b, sizeof(float) * cols, cudaMemcpyHostToDevice);
int numofthreads = work_per_block;
int size = rows;
int multiplier = floor(rows/work_per_block)+1;
if(rows<work_per_block){
multiplier = 1;
}
float cache = 11000 * sizeof(float);
// FEEDFORWARD FOR 1 ITERATION
// IN GPU
feedforward<<<cols, numofthreads, cache>>>(a_next, work_per_block, cols, m, v,
multiplier,size,biases,sigm_der);
cudaDeviceSynchronize();
cudaMemcpy(res, a_next, sizeof(float) * cols, cudaMemcpyDeviceToHost);
cudaMemcpy(sigm_der_gpu, sigm_der, sizeof(float) * cols, cudaMemcpyDeviceToHost);
// IN CPU
float* a_new = new float[cols];
cpu_feedforward(a_old,rows,cols,&a_new,w,b,sigm_der_result);
// COMPARE RESULTS
int success = 1;
for (int i = 0; i < cols; i++) {
// printf("kappa %f \n", res[i]);
if(a_new[i]!=res[i]){
printf("ERROR in a, cpu = %f, gpu = %f\n",a_new[i], res[i]);
success = 0;
}
if(sigm_der_gpu[i]!=sigm_der_result[i]){
printf("ERROR in a, cpu = %f, gpu = %f\n",sigm_der_result[i], sigm_der_gpu[i]);
success = 0;
}
}
/* Free memory */
cudaFree(a_next);
cudaFree(m);
cudaFree(v);
cudaFree(biases);
cudaFree(sigm_der);
if(success){
printf("SUCCESS \n");
}
return 0;
}
float* hadamard_product(int size, float* a, float* b) {
// returns the datamard product for vectors a and b
// (return a.*b in matlab)
// size = length of arrays a and b
float* result = new float[size];
for (int i = 0; i < size; i++) {
result[i] = a[i] * b[i];
}
return result;
}
float* mull_feedforward(int rows, int cols, float* matrix, float* vector) {
// TESTED
// returns "cols x 1" vector
float* temp = NULL;
float* res = new float[cols];
for (int j = 0; j < cols; j++) {
temp = hadamard_product(rows, &matrix[j * rows], vector);
res[j] = 0;
for (int i = 0; i < rows; i++) {
res[j] += temp[i];
}
delete[] temp;
}
return res;
}
void vector_add(int size, float* a, float* b) {
for (int i = 0; i < size; i++) {
a[i] += b[i];
}
}
float sigm(float z) {
return 1.0 / (1.0 + exp(-z));
}
void sigmoid(float** z, int size) {
for (int i = 0; i < size; i++) {
(*z)[i] = sigm(((*z)[i]));
}
}
float* compute_z(float* a, float* w, float* b, int rows, int cols) {
float* result = mull_feedforward(rows, cols, w, a);
vector_add(cols, result, b);
return result;
}
void compute_sigm_der(float* a, float* result, int size) {
for (int i = 0; i < size; i++) {
result[i] = a[i] * (1 - a[i]);
}
}
void cpu_feedforward(float* a_old,int rows, int cols,float** a_new,float* w,float* b,float* sigm_der_result) {
a_new[0] = compute_z(a_old, w, b, rows, cols);
sigmoid(&a_new[0], cols);
compute_sigm_der(a_new[0], sigm_der_result, cols);
}
|
2,716 | #include <stdint.h>
#define uint uint32_t
#define IDX(i,j,ld) (((i)*(ld))+(j))
#define IDX3(i,j,k,rows,cols) ((k)*(rows)*(cols)+(i)*(cols)+j)
#include<cufft.h>
#include<cuda.h>
//__global__ void copy_Kernel( real *out, const int *outm, const int *outn, real *in, const int ink, const int inm, const int inn, const int om, const int on, const int startRow){
// int i = blockIdx.x*BLOCK_SIZE + threadIdx.x;
// int j = blockIdx.y*BLOCK_SIZE + threadIdx.y;
//
// dy[IDX( om+i, on+j, outn )] += dys[IDX( startRow+i, j, inn )];
//}
__global__ void chop_mod_pad_Kernel(float *dx, int xm, int xn, int xr, float *dy, int ym, int yn, float *dw, int wm, int wn, int om, int on, int cm, int cn, int hopm, int hopn){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if ( i<(xm*xr) && j<xn ){
int k = i/xm;
int m = k/cn;
int n = k-(m*cn);
if( k < xr ){
if( ((k*xm)+om-1)<i && i<((k*xm)+wm+om) && (on-1)<j && j<(wn+on) ){
dx[IDX( i, j, xn)] = dw[IDX( (k*wm)-(k*xm)+i-om, j-on, wn)] * dy[IDX( (m*hopm)-(k*xm)+i-om, (n*hopn)+j-on, yn )];
}
else{
dx[IDX( i, j, xn )] = 0.0f;
}
}
}
}
__global__ void chop_mod_pad_ComplexKernel(cufftComplex *dx, int xm, int xn, int xr, float *dy, int ym, int yn, float *dw, int wm, int wn, int om, int on, int cm, int cn, int hopm, int hopn){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if ( i<(xm*xr) && j<xn ){
int k = i/xm;
int m = k/cn;
int n = k-(m*cn);
if( k < xr ){
if( ((k*xm)+om-1)<i && i<((k*xm)+wm+om) && (on-1)<j && j<(wn+on) ){
dx[IDX( i, j, xn)].x = dw[IDX( (k*wm)-(k*xm)+i-om, j-on, wn)] * dy[IDX( (m*hopm)-(k*xm)+i-om, (n*hopn)+j-on, yn )];
dx[IDX( i, j, xn)].y = 0.0f;
}
else{
dx[IDX( i, j, xn )].x = 0.0f;
dx[IDX( i, j, xn )].y = 0.0f;
}
}
}
}
__global__ void chop_pad_Kernel(float *dx, int xm, int xn, int xr, float *dy, int ym, int yn, int wm, int wn, int om, int on, int cm, int cn, int hopm, int hopn){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if ( i<(xm*xr) && j<xn ){
int k = i/xm;
int m = k/cn;
int n = k-(m*cn);
if( k < xr ){
if( ((k*xm)+om-1)<i && i<((k*xm)+wm+om) && (on-1)<j && j<(wn+on) ){
dx[IDX( i, j, xn)] = dy[IDX( (m*hopm)-(k*xm)+i-om, (n*hopn)+j-on, yn )];
}
else{
dx[IDX( i, j, xn )] = 0.0f;
}
}
}
}
__global__ void chop_pad_Kernel_test(float *out, const uint xm, const uint xn,
const uint xr, float *in,
const uint ym, const uint yn,
const uint wm, const uint wn,
const uint om, const uint on,
const uint cm, const uint cn,
const uint hopm, const uint hopn){
const uint i = (__umul24(blockIdx.x, blockDim.x) + threadIdx.x) / xn;
const uint j = (__umul24(blockIdx.x, blockDim.x) + threadIdx.x) % xn;
const uint k = (__umul24(blockIdx.y, blockDim.y) + threadIdx.y);
const uint i_patch = k / cn;
const uint j_patch = k % cn;
if (i >= xm || j >= xn || k >= xr )
return;
if (i >= om && j >= on && i < om+wm && j < on+wn) {
out[IDX3(i, j, k, xm, xn)] = in[IDX(i-om+__umul24(i_patch, hopm),
j-on+__umul24(j_patch, hopn), yn)];
}
else {
out[IDX3(i, j, k, xm, xn)] = 0.f;
}
}
__global__ void chop_pad_ComplexKernel(cufftComplex *dx, int xm, int xn, int xr, float *dy, int ym, int yn, int wm, int wn, int om, int on, int cm, int cn, int hopm, int hopn){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if ( i<(xm*xr) && j<xn ){
int k = i/xm;
int m = k/cn;
int n = k-(m*cn);
if( k < xr){
if( ((k*xm)+om-1)<i && i<((k*xm)+wm+om) && (on-1)<j && j<(wn+on) ){
dx[IDX( i, j, xn)].x = dy[IDX( (m*hopm)-(k*xm)+i-om, (n*hopn)+j-on, yn )];
dx[IDX( i, j, xn)].y = 0.0f;
}
else{
dx[IDX( i, j, xn )].x = 0.0f;
dx[IDX( i, j, xn )].y = 0.0f;
}
}
}
}
__global__ void chop_pad_ComplexKernel_test(cufftComplex *out, const uint xm,
const uint xn, const uint xr, float *in,
const uint ym, const uint yn,
const uint wm, const uint wn,
const uint om, const uint on,
const uint cm, const uint cn,
const uint hopm, const uint hopn){
const uint i = (__umul24(blockIdx.x, blockDim.x) + threadIdx.x) / xn;
const uint j = (__umul24(blockIdx.x, blockDim.x) + threadIdx.x) % xn;
const uint k = (__umul24(blockIdx.y, blockDim.y) + threadIdx.y);
const uint i_patch = k / cn;
const uint j_patch = k % cn;
if (i >= xm || j >= xn || k >= xr )
return;
if (i >= om && j >= on && i < om+wm && j < on+wn) {
out[IDX3(i, j, k, xm, xn)].x = in[IDX(i-om+__umul24(i_patch, hopm),
j-on+__umul24(j_patch, hopn), yn)];
out[IDX3(i, j, k, xm, xn)].y = 0.f;
}
else {
out[IDX3(i, j, k, xm, xn)].x = 0.f;
out[IDX3(i, j, k, xm, xn)].y = 0.f;
}
}
__global__ void zeroPadKernel(float *dx, int m, int n, float *dy, int p, int q, int s, int t){
int i = blockIdx.y*blockDim.y + threadIdx.y;
int j = blockIdx.x*blockDim.x + threadIdx.x;
if ( i<m && j<n ){
if( (s-1)<i && i<(p+s) && (t-1)<j && j<(q+t) ){
dx[IDX( i, j, n )] = dy[IDX( i-s, j-t, q )];
}
else{
dx[IDX( i, j, n )] = 0.0f;
}
}
}
__global__ void zeroPadComplexKernel(cufftComplex *dx, int m, int n, float *dy, int p, int q, int s, int t){
int i = blockIdx.y*blockDim.y + threadIdx.y;
int j = blockIdx.x*blockDim.x + threadIdx.x;
if ( i<m && j<n ){
if( (s-1)<i && i<(p+s) && (t-1)<j && j<(q+t) ){
dx[IDX( i, j, n )].x = dy[IDX( i-s, j-t, q )];
dx[IDX( i, j, n )].y = 0.0f;
}
else{
dx[IDX( i, j, n )].x = 0.0f;
dx[IDX( i, j, n )].y = 0.0f;
}
}
}
__global__ void pad_stack_Kernel(float *dx, int xk, int xm, int xn, float *dxp, int pm, int pn, int om, int on){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if ( i<(pm*xk) && j<(pn) ){
int k = i/pm;
if( k < xk ){
if( ((k*pm)+om-1)<i && i<((k*pm)+xm+om) && (on-1)<j && j<(xn+on) ){
dxp[IDX( i, j, pn) ] = dx[IDX( i-om+(k*(xm-pm)), j-on, xn )];
}
else{
dxp[IDX( i, j, pn )] = 0.0f;
}
}
}
}
__global__ void pad_stack_ComplexKernel(float *dx, int xk, int xm, int xn, cufftComplex *dxp, int pm, int pn, int om, int on){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if ( i<(pm*xk) && j<(pn) ){
int k = i/pm;
if( k < xk ){
if( ((k*pm)+om-1)<i && i<((k*pm)+xm+om) && (on-1)<j && j<(xn+on) ){
dxp[IDX( i, j, pn) ].x = dx[IDX( i-om+(k*(xm-pm)), j-on, xn )];
dxp[IDX( i, j, pn) ].y = 0.0f;
}
else{
dxp[IDX( i, j, pn )].x = 0.0f;
dxp[IDX( i, j, pn )].y = 0.0f;
}
}
}
}
__global__ void crop_stack_Kernel(float *dx, int xk, int xm, int xn, float *dxp, int pm, int pn, int om, int on){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int k = i/xm;
if( k < xk ){
if( ((k*xm)-1)<i && i<((k+1)*xm) && j<xn){
dx[IDX( i, j, xn) ] = dxp[IDX( i+om+(k*(pm-xm)), j+on, pn )];
}
}
}
__global__ void crop_stack_ComplexKernel(cufftComplex *dx, int xk, int xm, int xn, cufftComplex *dxp, int pm, int pn, int om, int on){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int k = i/xm;
if( k < xk){
if( ((k*xm)-1)<i && i<((k+1)*xm) && j<xn){
dx[IDX( i, j, xn) ].x = dxp[IDX( i+om+(k*(pm-xm)), j+on, pn )].x;
dx[IDX( i, j, xn) ].y = dxp[IDX( i+om+(k*(pm-xm)), j+on, pn )].y;
}
}
}
__global__ void crop_Kernel(float *dx, int m, int n, float *dy, int p, int q, int s, int t){
int i = blockIdx.y*blockDim.y + threadIdx.y;
int j = blockIdx.x*blockDim.x + threadIdx.x;
if ( (s-1)<i && i<m+s ){
if( (t-1)<j && j<n+t ){
dx[IDX( i-s, j-t, n )] = dy[IDX( i, j, q )];
}
}
}
__global__ void crop_ComplexKernel(float *dx, int m, int n, cufftComplex *dy, int p, int q, int s, int t){
int i = blockIdx.y*blockDim.y + threadIdx.y;
int j = blockIdx.x*blockDim.x + threadIdx.x;
if ( (s-1)<i && i<m+s ){
if( (t-1)<j && j<n+t ){
dx[IDX( i-s, j-t, n )] = dy[IDX( i, j, q )].x;
}
}
}
__global__ void ola_ComplexKernel_test(float *out, cufftComplex *in, const uint outm, const uint outn, const uint inm, const uint inn, const uint wm, const uint wn, const uint om, const uint on, const uint cm,const uint cn, const uint hopm, const uint hopn) {
const int i = __umul24(blockIdx.y, blockDim.y) + threadIdx.y;
const int j = __umul24(blockIdx.x, blockDim.x) + threadIdx.x;
if (0<=i && i<outm && 0<=j && j<outn){
const int ci = min(i / hopm, cm - 1);
const int cj = min(j / hopn, cn - 1);
float result = 0.f;
for (int d_i = 0; i<wm+hopm*(ci-d_i) && ci-d_i>=0; d_i++) {
for (int d_j = 0; j<wn+hopn*(cj-d_j) && cj-d_j>=0; d_j++) {
result += in[IDX3(om+i+(d_i-ci)*hopm,
on+j+(d_j-cj)*hopn,
IDX(ci-d_i,cj-d_j,cn),inm,inn)].x;
}
}
out[IDX(i,j,outn)] = result;
}
}
__global__ void ola_Kernel_test(float *out, float *in, const uint outm, const uint outn, const uint inm, const uint inn, const uint wm, const uint wn, const uint om, const uint on, const uint cm,const uint cn, const uint hopm, const uint hopn) {
const int i = __umul24(blockIdx.y, blockDim.y) + threadIdx.y;
const int j = __umul24(blockIdx.x, blockDim.x) + threadIdx.x;
if (0<=i && i<outm && 0<=j && j<outn){
const int ci = min(i / hopm, cm - 1);
const int cj = min(j / hopn, cn - 1);
float result = 0.f;
for (int d_i = 0; i<wm+hopm*(ci-d_i) && ci-d_i>=0; d_i++) {
for (int d_j = 0; j<wn+hopn*(cj-d_j) && cj-d_j>=0; d_j++) {
result += in[IDX3(om+i+(d_i-ci)*hopm,
on+j+(d_j-cj)*hopn,
IDX(ci-d_i,cj-d_j,cn),inm,inn)];
}
}
out[IDX(i,j,outn)] = result;
}
}
__global__ void comp_ola_deconv_Kernel(cufftComplex *out, const int outk, const int outm, const int outn, cufftComplex *f, cufftComplex *y, cufftComplex *L, const float alpha, const float beta) {
const int i = blockIdx.x*blockDim.x + threadIdx.x;
const int j = blockIdx.y*blockDim.y + threadIdx.y;
const int k = i / outm;
if(k < outk){
if(((k*outm)-1)<i && i<((k+1)*outm) && j<(outn)){
const float numx = f[IDX(i,j,outn)].x * y[IDX(i,j,outn)].x +
f[ IDX(i,j,outn)].y * y[IDX(i,j,outn)].y;
const float numy = -f[IDX(i,j,outn)].y * y[IDX(i,j,outn)].x +
f[IDX(i,j,outn)].x * y[IDX(i,j,outn)].y;
const float denomx = f[IDX(i,j,outn)].x * f[IDX(i,j,outn)].x +
f[IDX(i,j,outn)].y * f[IDX(i,j,outn)].y +
alpha * L[IDX(i-(k*outm),j,outn)].x + beta;
const float denomy = alpha * L[IDX(i-(k*outm),j,outn)].y;
out[IDX(i,j,outn)].x = (numx * denomx + numy * denomy) /
(denomx * denomx + denomy * denomy);
out[IDX(i,j,outn)].y = (numy * denomx - numx * denomy) /
(denomx * denomx + denomy * denomy);
}
}
}
__global__ void comp_ola_gdeconv_Kernel(cufftComplex *out, const int outk, const int outm, const int outn, cufftComplex *xx, cufftComplex *xy, cufftComplex *yx, cufftComplex *yy, cufftComplex *L, const float alpha, const float beta) {
const int i = blockIdx.x*blockDim.x + threadIdx.x;
const int j = blockIdx.y*blockDim.y + threadIdx.y;
const int k = i/outm;
if( k < outk ){
if( ((k*outm)-1)<i && i<((k+1)*outm) && j<(outn) ){
const float numx = xx[ IDX(i, j, outn) ].x * yx[ IDX(i, j, outn) ].x +
xx[ IDX(i, j, outn) ].y * yx[ IDX(i, j, outn) ].y +
xy[ IDX(i, j, outn) ].x * yy[ IDX(i, j, outn) ].x +
xy[ IDX(i, j, outn) ].y * yy[ IDX(i, j, outn) ].y;
const float numy = -xx[ IDX(i, j, outn) ].y * yx[ IDX(i, j, outn) ].x +
xx[ IDX(i, j, outn) ].x * yx[ IDX(i, j, outn) ].y
-xy[ IDX(i, j, outn) ].y * yy[ IDX(i, j, outn) ].x +
xy[ IDX(i, j, outn) ].x * yy[ IDX(i, j, outn) ].y;
const float denomx = xx[ IDX(i, j, outn) ].x * xx[ IDX(i, j, outn) ].x +
xx[ IDX(i, j, outn) ].y * xx[ IDX(i, j, outn) ].y +
xy[ IDX(i, j, outn) ].x * xy[ IDX(i, j, outn) ].x +
xy[ IDX(i, j, outn) ].y * xy[ IDX(i, j, outn) ].y +
alpha * L[ IDX(i-(k*outm), j, outn) ].x + beta;
const float denomy = alpha * L[ IDX(i-(k*outm), j, outn) ].y;
out[IDX( i, j, outn) ].x = ( numx * denomx + numy * denomy)/
(denomx * denomx + denomy * denomy);
out[IDX( i, j, outn) ].y = ( numy * denomx - numx * denomy)/
(denomx * denomx + denomy * denomy);
}
}
}
__global__ void comp_ola_sdeconv_Kernel(cufftComplex *out, const int outk, const int outm, const int outn, cufftComplex *gx, cufftComplex *gy, cufftComplex *xx, cufftComplex *xy, cufftComplex *Ftpy, cufftComplex *f, cufftComplex *L, const float alpha, const float beta, const float gamma) {
const int i = blockIdx.x*blockDim.x + threadIdx.x;
const int j = blockIdx.y*blockDim.y + threadIdx.y;
const int k = i/outm;
if( k < outk ){
if( ((k*outm)-1)<i && i<((k+1)*outm) && j<(outn) ){
const float numx = gx[ IDX(i-(k*outm), j, outn) ].x * xx[ IDX(i, j, outn) ].x +
gx[ IDX(i-(k*outm), j, outn) ].y * xx[ IDX(i, j, outn) ].y +
gy[ IDX(i-(k*outm), j, outn) ].x * xy[ IDX(i, j, outn) ].x +
gy[ IDX(i-(k*outm), j, outn) ].y * xy[ IDX(i, j, outn) ].y +
Ftpy[ IDX(i, j, outn) ].x / (alpha * beta);
const float numy = -gx[ IDX(i-(k*outm), j, outn) ].y * xx[ IDX(i, j, outn) ].x +
gx[ IDX(i-(k*outm), j, outn) ].x * xx[ IDX(i, j, outn) ].y
-gy[ IDX(i-(k*outm), j, outn) ].y * xy[ IDX(i, j, outn) ].x +
gy[ IDX(i-(k*outm), j, outn) ].x * xy[ IDX(i, j, outn) ].y +
Ftpy[ IDX(i, j, outn) ].y / (alpha * beta);
const float denomx = (f[ IDX(i, j, outn) ].x * f[ IDX(i, j, outn) ].x +
f[ IDX(i, j, outn) ].y * f[ IDX(i, j, outn) ].y ) / (alpha * beta) +
L[ IDX(i-(k*outm), j, outn) ].x + gamma;
const float denomy = L[ IDX(i-(k*outm), j, outn) ].y;
out[IDX( i, j, outn) ].x = ( numx * denomx + numy * denomy)/
(denomx * denomx + denomy * denomy);
out[IDX( i, j, outn) ].y = ( numy * denomx - numx * denomy)/
(denomx * denomx + denomy * denomy);
}
}
}
|
2,717 | #include "includes.h"
__global__ void tanhActivationBackprop(float* Z, float* dA, float* dZ, int Z_x_dim, int Z_y_dim) {
int index = blockIdx.x * blockDim.x + threadIdx.x;
if (index < Z_x_dim * Z_y_dim) {
float d = Z[index];
dZ[index] = dA[index] * (1 - d * d);
}
} |
2,718 | #include <sys/time.h>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#define BLOCK_SIZE 16
#ifndef DEVICE_COUNT
#define DEVICE_COUNT 1
#endif
void print_matrix_2D(double *A, int rows, int cols)
{
for (int i = 0; i < rows; ++i)
{
for (int j = 0; j < cols; ++j)
printf("%.0f ", A[i * cols + j]);
printf("\n");
}
printf("\n");
}
__global__ void gpu_matrix_mult(double *a, double *b, double *c, int ms, int me, int n, int k)
{
int row = blockIdx.y * blockDim.y + threadIdx.y;
int col = blockIdx.x * blockDim.x + threadIdx.x;
float sum = 0;
if (col < k && row >= ms && row < me)
{
for (int i = 0; i < n; i++)
sum += a[row * n + i] * b[i * k + col];
c[row * k + col] = sum;
}
}
int main(int argc, char *argv[])
{
if (argc < 4)
{
printf("use ./gdmm_cuda m n k\n");
return 1;
}
int m = atoi(argv[1]), n = atoi(argv[2]), k = atoi(argv[3]);
double *a = new double[m * n];
double *b = new double[n * k];
double *c = new double[m * k];
int *min_rows = new int[m];
srand(time(0));
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
a[i * n + j] = rand() % 1024 + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++)
b[i * k + j] = rand() % 1024 + 1;
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
double *d_a[DEVICE_COUNT], *d_b[DEVICE_COUNT], *d_c[DEVICE_COUNT];
int *d_min_rows[DEVICE_COUNT];
for (int i = 0; i < DEVICE_COUNT; i++)
{
cudaSetDevice(i);
cudaMalloc((void **)&d_a[i], sizeof(double) * m * n);
cudaMalloc((void **)&d_b[i], sizeof(double) * n * k);
cudaMalloc((void **)&d_c[i], sizeof(double) * m * k);
cudaMalloc((void **)&d_min_rows[i], sizeof(int) * m);
cudaMemcpy(d_a[i], a, sizeof(double) * m * n, cudaMemcpyHostToDevice);
cudaMemcpy(d_b[i], b, sizeof(double) * n * k, cudaMemcpyHostToDevice);
cudaMemcpy(d_min_rows[i], min_rows, sizeof(int) * m, cudaMemcpyHostToDevice);
}
unsigned int grid_rows = (m + BLOCK_SIZE - 1) / BLOCK_SIZE;
unsigned int grid_cols = (k + BLOCK_SIZE - 1) / BLOCK_SIZE;
dim3 numBlocks(grid_cols, grid_rows);
dim3 blockSize(BLOCK_SIZE, BLOCK_SIZE);
cudaEventRecord(start, 0);
for (int i = 0; i < DEVICE_COUNT; i++)
{
cudaSetDevice(i);
int ms = m / DEVICE_COUNT * i, me = m / DEVICE_COUNT * (i + 1);
int device_mem = m * k / DEVICE_COUNT;
gpu_matrix_mult<<<numBlocks, blockSize>>>(d_a[i], d_b[i], d_c[i], ms, me, n, k);
cudaMemcpy(c + (device_mem * i), d_c[i] + (device_mem * i), sizeof(double) * device_mem, cudaMemcpyDeviceToHost);
cudaThreadSynchronize();
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
}
float gpu_elapsed_time_ms;
cudaEventElapsedTime(&gpu_elapsed_time_ms, start, stop);
printf("%f\n", gpu_elapsed_time_ms);
return 0;
}
|
2,719 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cuda.h>
#define ThreadNum 256
__global__ void printBase(int **base, int length) {
int t_id = threadIdx.x;
int b_id = blockIdx.x;
if (t_id < length) {
printf("block:%d-%d : %d\n", b_id, t_id, base[b_id][t_id]);
}
}
int main(int agrc, char *argv[]) {
int limit = atoi(argv[1]);
int **base;
cudaMallocManaged(&base, sizeof(int*) * limit);
cudaDeviceSynchronize();
int i, j;
for (i = 0; i < limit; i ++) {
cudaMallocManaged(&base[i], sizeof(int) * 256);
for (j = 0; j < ThreadNum; j ++) {
base[i][j] = i * 1000 + j;
}
}
int block_num = limit;
printBase<<<block_num, ThreadNum>>>(base, ThreadNum);
cudaDeviceSynchronize();
cudaDeviceReset();
cudaFree(base);
return 0;
}
|
2,720 | /*
Faz a soma dos elementos de dois vetores
Exemplifica o uso de diferentes streams (1 e 2) com cudaMallocHost
para alocar memoria no host nao paginavel e copia assincrona
com cudaMemcpyAsync. Usa tambem o cudaStreamSynchronize para
aguardar toda a stream terminar.
O algoritmo divide "tam" elementos por "streams_nr*2" e encontra "threadsPerGrid" e "blocksPerGrid".
Sao invocadas duas streams (1 e 2) a cada iteracao do loop for, por isso a multiplicacao por 2.
O vetor no device tem o tamanho de threadsPerGrid.
Caso o nr de streams provoque uma divisao com resto, a ultima grade da stream acerta o resto
Caso o nr de threads por bloco provoque uma divisao com resto, o algoritmo funciona fitra o excesso
Para compilar: nvcc 04-soma-vet-stream-2.cu -o 04-soma-vet-stream-2
Para executar: ./04-soma-vet-stream-2
OBS: os valores de tamanho do vetor e o conteudo do vetor
estao fixos no codigo
*/
#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
__global__ void soma(int *vetorA, int *vetorB, int *vetorC, int tam, int iter, int strm)
{
int idx = blockDim.x * blockIdx.x + threadIdx.x;
if (idx < tam)
{
vetorC[idx]=vetorA[idx]+vetorB[idx];
printf("Iter=%d, Stream=%d, Blc=%d, Thread=%d, Tam=%d, VetC[%d]=%d \n", iter, strm, blockIdx.x, threadIdx.x, tam, idx, vetorC[idx]);
}
}
int main(int argc,char **argv)
{
int i,*vetorA,*vetorB,*vetorC,threadsPerBlock;
//Declara os vetores para uso na primeira stream
int *vetorA_d1,*vetorB_d1,*vetorC_d1;
//Declara os vetores para uso na segundo stream
int *vetorA_d2,*vetorB_d2,*vetorC_d2;
//Declaração da variável do tipo cudaStream_t
cudaStream_t stream1,stream2;
//Criação das streams
cudaStreamCreate(&stream1);
cudaStreamCreate(&stream2);
//Define o tamanho do vetor, multiplo de 256
int tam = 16; // 16; // 2048;
//Define a quantidade de threads por bloco
threadsPerBlock = 2; //2; //256;
//Define quantas streams usar
int streams_nr = 2;
//Define o nr de threads por grade (uma grade por vez na stream)
// divide por 2 pq sao executadas duas grades por iteracao do for abaixo.
// cada grade ira executar em uma stream diferente (stream 1 e stream 2)
int threadsPerGrid=(tam/streams_nr)/2; // threadsPerGrid=4 (16/2)/2 // =512 (2048/2)/2
// 17 / 2 / 2 = 4 (8,5 / 2 = 4,25)
//Define a quantidade de blocos por grade
int blocksPerGrid=(threadsPerGrid+threadsPerBlock-1)/threadsPerBlock; // blockPerStream=4 (8/2) // =4 (1024/256)
// (4+1)/2 ==> 2 (2,5)
// (512+255)/256 ==> 2 (2,9960)
// (4+1)/2 ==> 2 (2,5)
//Aloca os vetores no host usando pinned pages
cudaMallocHost((void**)&vetorA,tam*(sizeof(int)));
cudaMallocHost((void**)&vetorB,tam*(sizeof(int)));
cudaMallocHost((void**)&vetorC,tam*(sizeof(int)));
//Aloca os vetores no device para a stream 1
cudaMalloc((void**)&vetorA_d1,threadsPerGrid*(sizeof(int)));
cudaMalloc((void**)&vetorB_d1,threadsPerGrid*(sizeof(int)));
cudaMalloc((void**)&vetorC_d1,threadsPerGrid*(sizeof(int)));
//Aloca os vetores no device para a stream 2
cudaMalloc((void**)&vetorA_d2,threadsPerGrid*(sizeof(int)));
cudaMalloc((void**)&vetorB_d2,threadsPerGrid*(sizeof(int)));
cudaMalloc((void**)&vetorC_d2,threadsPerGrid*(sizeof(int)));
//Preenche os vetores no host
for(i=0;i<tam;i++)
{
vetorA[i]= i;
vetorB[i]= 0; //-i;
}
printf("Host: tam=%d, streams_nr=%d, TPG=%d, BPG=%d, TPB=%d \n", tam, streams_nr, threadsPerGrid, blocksPerGrid, threadsPerBlock);
for(i=0;i<tam;i+=threadsPerGrid*2) // i+=4*2 // i+=512*2 (*2 pq sao duas streams por iter)
{
// caso tenha mais streams que o necessario, precisa acertar o tamanho do bloco na ultima stream
// essa ultima stream pega apenas o restante para processas; nao o vlr cheios de threadsPerGrid
if((tam-i)< (threadsPerGrid*2))
threadsPerGrid = tam - i;
//copia um bloco de tamanho threadsPerGrid do vetor A do host para o device (stream1)
cudaMemcpyAsync(vetorA_d1,vetorA+i,threadsPerGrid*(sizeof(int)),cudaMemcpyHostToDevice,stream1);
//copia um bloco de tamanho threadsPerGrid do vetor B do host para o device (stream1)
cudaMemcpyAsync(vetorB_d1,vetorB+i,threadsPerGrid*(sizeof(int)),cudaMemcpyHostToDevice,stream1);
//Invoca o kernel soma passando a stream 1 como argumento
soma <<<blocksPerGrid,threadsPerBlock,0,stream1>>> (vetorA_d1,vetorB_d1,vetorC_d1,threadsPerGrid,i,1);
//Copia um bloco de tamanho bloco do resultado da stream 1 de volta para o host
cudaMemcpyAsync(vetorC+i,vetorC_d1,threadsPerGrid*(sizeof(int)),cudaMemcpyDeviceToHost,stream1);
if(i+threadsPerGrid < tam)
{ // se a segunda stream ainda tem computacao a fazer...
//copia um bloco de tamanho bloco do vetor A do host para o device (stream2)
cudaMemcpyAsync(vetorA_d2,vetorA+i+threadsPerGrid,threadsPerGrid*(sizeof(int)),cudaMemcpyHostToDevice,stream2);
//copia um bloco de tamanho bloco do vetor B do host para o device (stream2)
cudaMemcpyAsync(vetorB_d2,vetorB+i+threadsPerGrid,threadsPerGrid*(sizeof(int)),cudaMemcpyHostToDevice,stream2);
//Invoca o kernel soma passando a stream 2 como argumento
soma <<<blocksPerGrid,threadsPerBlock,0,stream2>>> (vetorA_d2,vetorB_d2,vetorC_d2,threadsPerGrid,i,2);
//Copia um bloco de tamanho bloco do resultado da stream 2 de volta para o host
cudaMemcpyAsync(vetorC+i+threadsPerGrid,vetorC_d2,threadsPerGrid*(sizeof(int)),cudaMemcpyDeviceToHost,stream2);
}
}
//Sincroniza as streams
cudaStreamSynchronize(stream1);
cudaStreamSynchronize(stream2);
//Imprime o resultado no host
for(i=0;i<tam;i++)
{
printf("%d ",vetorC[i]);
}
//Desaloca os vetores no host
cudaFreeHost(vetorA);
cudaFreeHost(vetorB);
cudaFreeHost(vetorC);
//Desaloca os vetores da stream 1
cudaFree(vetorA_d1);
cudaFree(vetorB_d1);
cudaFree(vetorC_d1);
//Desaloca os vetores da stream 2
cudaFree(vetorA_d2);
cudaFree(vetorB_d2);
cudaFree(vetorC_d2);
//Destroi as streams
cudaStreamDestroy(stream1);
cudaStreamDestroy(stream2);
}
|
2,721 | #include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef signed char schar;
typedef unsigned char uchar;
typedef short shrt;
typedef unsigned short ushrt;
typedef unsigned uint;
typedef unsigned long ulong;
typedef long long llong;
typedef unsigned long long ullong;
typedef float flt;
typedef double dbl;
typedef long double ldbl;
#define exit_if(cnd_value, msg) \
do { \
if (cnd_value) \
{ \
if (errno) \
perror(msg); \
else \
fprintf(stderr, "error: %s\n", msg); \
exit(EXIT_FAILURE); \
} \
} while (0)
#define cudaErrorCheck(error) \
do { \
cudaError_t res = error; \
if (res != cudaSuccess) \
{ \
fprintf(stderr, "cuda %s:%d error: %s\n", __FILE__, __LINE__, \
cudaGetErrorString(res)); \
exit(EXIT_FAILURE); \
} \
} while(0)
#define NUM_BLOCKS (1024)
#define BLOCK_SIZE (1024)
__global__ void kernel(dbl * const __restrict__ first,
const dbl * const __restrict__ second,
const size_t n)
{
const size_t offset = gridDim.x * blockDim.x;
size_t idx = blockDim.x * blockIdx.x + threadIdx.x;
while (idx < n)
{
first[idx] -= second[idx];
idx += offset;
}
}
int main(void)
{
size_t n;
scanf("%zu", &n);
dbl * const first = (dbl *) malloc(sizeof(dbl) * n),
* const second = (dbl *) malloc(sizeof(dbl) * n);
exit_if(!first || !second, "malloc()");
memset(first, 0, n * sizeof(dbl));
memset(second, 0, n * sizeof(dbl));
dbl *device_first, *device_second;
cudaErrorCheck(cudaMalloc(&device_first, sizeof(dbl) * n));
cudaErrorCheck(cudaMemcpy(device_first, first, sizeof(dbl) * n,
cudaMemcpyHostToDevice));
cudaErrorCheck(cudaMalloc(&device_second, sizeof(dbl) * n));
cudaErrorCheck(cudaMemcpy(device_second, second, sizeof(dbl) * n,
cudaMemcpyHostToDevice));
cudaEvent_t start, stop;
cudaErrorCheck(cudaEventCreate(&start));
cudaErrorCheck(cudaEventCreate(&stop));
cudaErrorCheck(cudaEventRecord(start, 0));
kernel<<<NUM_BLOCKS, BLOCK_SIZE>>>(device_first, device_second, n);
cudaErrorCheck(cudaGetLastError());
cudaErrorCheck(cudaEventRecord(stop, 0));
cudaErrorCheck(cudaEventSynchronize(stop));
flt time;
cudaErrorCheck(cudaEventElapsedTime(&time, start, stop));
cudaErrorCheck(cudaEventDestroy(start));
cudaErrorCheck(cudaEventDestroy(stop));
printf("time = %f\n", time);
cudaErrorCheck(cudaMemcpy(first, device_first, sizeof(dbl) * n,
cudaMemcpyDeviceToHost));
cudaErrorCheck(cudaFree(device_first));
cudaErrorCheck(cudaFree(device_second));
free(first);
free(second);
return 0;
}
|
2,722 | #include <thrust/device_vector.h>
#include <thrust/copy.h>
#include <stdio.h>
#include <iostream>
#include <time.h>
#include <chrono>
struct is_even{
__host__ __device__
bool operator () (const int x){
return (x & 1) == 0;
}
};
int main(int argc, char** argv){
int size = atoi(argv[1]);
thrust::device_vector<int> test(size);
thrust::fill(test.begin(), test.end(), 1);
auto started = std::chrono::high_resolution_clock::now();
thrust::device_vector<int> res(size);
thrust::copy_if(test.begin(), test.end(), res.begin(), is_even());
auto end = std::chrono::high_resolution_clock::now();
printf("Thrust time %.4f\n", (std::chrono::duration_cast<std::chrono::milliseconds>(end - started).count()) / 1000.0);
return 0;
}
|
2,723 | #include <stdio.h>
#include <math.h>
void printMatrix(const int *A, int rows, int cols) {
for(int i = 0; i < rows*cols*4; i++){
printf("%d ", A[i]);
printf(" ");
if ((i+1)%4 == 0){
printf("|");
}
}
printf("\n");
};
void readInput_aos(const char *filename, int **Aos, int *rows, int *cols) {
FILE *file;
file = fopen(filename, "r");
fscanf(file, "%d %d", rows, cols);
int * A_F1 = (int *) malloc(*rows * (*cols)* (4) * sizeof(int));
for(int j = 0; j < 4; j++) {
int counter = 0;
for(int i = 0; i < *cols*(*rows); i++){
fscanf(file, "%d ", &A_F1[counter +j]);
counter = counter + 4;
}
}
fclose(file);
*Aos = A_F1;
}
__global__ void step_periodic(int * array,int *buffer,int rows, int cols){
int tId = threadIdx.x + blockIdx.x * blockDim.x;
if(tId < rows*cols){
int x = tId%(cols);
int y = (int) tId/rows;
int c_aux = x -1;
if (c_aux < 0){
c_aux = cols -1;
}
if (buffer[(y*cols + c_aux)*4 + 1] == 1 && buffer[(y*cols + c_aux)*4 + 3] == 1){
array[tId*4] = 1;
}else if (buffer[(y*cols + c_aux)*4] == 1 && buffer[(y*cols + c_aux) + 2] == 1){
array[tId*4] = 0;
}else if (buffer[(y*cols + c_aux)*4] == 1){
array[tId*4] = 1;
}else if (buffer[(y*cols + c_aux)*4] == 0){
array[tId*4] = 0;
}
c_aux = x + 1;
if (c_aux == cols){
c_aux = 0;
}
if (buffer[(y*cols + c_aux)*4+1] == 1 && buffer[(y*cols + c_aux)*4 + 3] == 1){
array[tId*4+2] = 1;
}else if (buffer[(y*cols + c_aux)*4] == 1 && buffer[(y*cols + c_aux)*4 + 2] == 1){
array[tId*4+2] = 0;
}else if (buffer[(y*cols + c_aux)*4+ 2] == 1){
array[tId*4+2] = 1;
}else if (buffer[(y*cols + c_aux)*4+ 2] == 0){
array[tId*4+2] = 0;
}
c_aux = (((y-1)%rows)+rows)%rows*cols;
if (buffer[(c_aux + x)*4] == 1 && buffer[(c_aux + x)*4+2] == 1){
array[tId*4+1] = 1;
}else if (buffer[(c_aux + x)*4+1] == 1 && buffer[(c_aux + x)*4+3] == 1){
array[tId*4+1] = 0;
}else if (buffer[ (c_aux + x)*4 + 1 ] == 1){
array[tId*4+1] = 1;
}else if (buffer[ (c_aux + x)*4 + 1 ] == 0){
array[tId*4+1] = 0;
}
c_aux = (((y+1)%rows)*cols);
if (buffer[(c_aux + x)*4] == 1 && buffer[(c_aux + x)*4 + 2] == 1){
array[tId*4+3] = 1;
}else if (buffer[(c_aux + x)*4+1] == 1 && buffer[(c_aux + x)*4 + 3] == 1){
array[tId*4+3] = 0;
}else if (buffer[ (c_aux + x)*4 + 3 ] == 1){
array[tId*4+3] = 1;
}else if (buffer[ (c_aux + x)*4 +3] == 0){
array[tId*4+3] = 0;
}
}
}
int main(int argc, char const *argv[])
{
int rows, cols;
int *array;
int *d_array;
int *d_buffer;
readInput_aos("../initial.txt", &array, &rows, &cols);
int n = (int)(rows*cols);
int block_size = 256;
int grid_size = (int) ceil((float) n/ block_size);
cudaMalloc(&d_array ,4*rows * cols * sizeof(int));
cudaMalloc(&d_buffer,4*rows*cols*sizeof(int));
cudaMemcpy(d_array, array,4* rows * cols * sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_buffer, array,4* rows * cols * sizeof(int), cudaMemcpyHostToDevice);
for(int k = 0; k < 1000; k++){
step_periodic<<<grid_size, block_size>>>(d_array, d_buffer, rows, cols);
cudaMemcpy(d_buffer,d_array,4*rows*cols * sizeof(int), cudaMemcpyDeviceToDevice);
}
cudaMemcpy(array, d_array, 4*rows * cols * sizeof(int), cudaMemcpyDeviceToHost);
cudaFree(d_array);
cudaFree(d_buffer);
return(0);
}
|
2,724 | #include "includes.h"
__global__ void repeat_x_for_clusters(float * x,int size)
{
int index = blockIdx.x * blockDim.x + threadIdx.x ;
int thread_index = threadIdx.x ;
int block_index = blockIdx.x ;
if (block_index > 0 && index < size)
{
x[index] = x[thread_index] ;
}
} |
2,725 | #include "includes.h"
__global__ void convertPitchedFloatToGrayRGBA_kernel(uchar4 *out_image, const float *in_image, int width, int height, int pitch, float lowerLim, float upperLim) {
const int x = __mul24(blockIdx.x, blockDim.x) + threadIdx.x;
const int y = __mul24(blockIdx.y, blockDim.y) + threadIdx.y;
uchar4 temp;
if (x < width && y < height) {
// float val = in_image[__mul24(y,pitch)+x];
float val = *((float *)((char *)in_image + y * pitch) + x);
// rescale value from [lowerLim,upperLim] to [0,255]
val -= lowerLim;
val /= (upperLim - lowerLim);
val *= 255.0;
temp.x = val;
temp.y = val;
temp.z = val;
temp.w = 255;
out_image[__mul24(y, width) + x] = temp;
}
} |
2,726 | #include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <cuda.h>
#include <fstream>
#include <string>
#include <cstdlib>
#include <math.h>
#include <algorithm>
#include <bitset>
#include <iomanip>
using namespace std;
__global__ void twodimconvol(float *a, float *h, float *c, int kY, int kX, int dY, int dX,int newx,int newy)
{
//Launching X and Y threadIDS for computation
int x=blockIdx.x*blockDim.x + threadIdx.x;
int y=blockIdx.y*blockDim.y + threadIdx.y;
int i,j;
//Sum variable used for final result convolution at (i,j)
float sum = 0.0;
//IF Statement used because I have by default 16 by 16 blksize incase op is small thenfor that case it is used
if(x < newx){
if(y < newy){
for(i=0;i < kY; ++i)
{
for(j=0; j < kX; ++j)
{
sum += h[kX * i + j]*a[((y-i+kY-1)*(dX))+(x-j + kX-1)];
}
}
c[(dX-(kX-1)) * y + x] = sum;
}
}
}
int main (int argc, char* argv[])
{
int dY, dX,kY, kX;
ifstream infile;
int stat1 = 0,stat2 = 0,col1 = 0,col2 = 0;
infile.open(argv[1]); // open a file
ifstream file2;
file2.open(argv[1]);
string A;
while (!file2.eof())
{
char buffer[512];
file2.getline(buffer,512);
if(strcmp(buffer,"") == 0){
break;
}
else{
int n = 0;
// array to store memory addresses of the tokens in buf
const char* token[250] = {}; // initialize to 0
// parse the line
token[0] = strtok(buffer," "); // first token
if (token[0]) // zero if line is blank
{
for (n = 1; n < 250; n++)
{
token[n] = strtok(0, " "); // subsequent tokens
if (!token[n]) break; // no more tokens
}
col2 = n;
}
// process (print) the tokens
for (int i = 0; i < n; i++){ // n = #of tokens
//cout << "Token[" << i << "] = " << token[i] << endl;
stat2++;
}
//cout << endl;
}
}
while (!file2.eof())
{
char buffer[512];
file2.getline(buffer,512);
int n = 0;
// array to store memory addresses of the tokens in buf
const char* token[250] = {}; // initialize to 0
// parse the line
token[0] = strtok(buffer," "); // first token
if (token[0]) // zero if line is blank
{
for (n = 1; n < 250; n++)
{
token[n] = strtok(0, " "); // subsequent tokens
if (!token[n]) break; // no more tokens
}
col1 = n;
}
// process (print) the tokens
for (int i = 0; i < n; i++){ // n = #of tokens
//cout << "Token[" << i << "] = " << token[i] << endl;
//check1[stat1] = atof(token[i]);
//cout << check1[stat1] << endl;
stat1++;
}
//cout << endl;
if(file2.eof())
break;
}
//cout << stat1 << " " << stat2 << " " << col1 << " " << col2 << endl;
//Allocating matrix a1 and a2 based on file parsed above which gives us dimension
float *a1,*a2;
a1 = new float [stat2];
a2 = new float [stat1];
for(int i = 0;i < stat2 ;i++)
a1[i] = 0.0;
for(int i = 0;i < stat1;i++)
a2[i] = 0.0;
int dum1=0,dum2=0;
//Actual read of matrices a1 and a2
while (!infile.eof())
{
char buffer[512];
infile.getline(buffer,512);
if(strcmp(buffer,"") == 0){
break;
}
else{
int n = 0;
// array to store memory addresses of the tokens in buf
const char* token[250] = {}; // initialize to 0
// parse the line
token[0] = strtok(buffer," "); // first token
if (token[0]) // zero if line is blank
{
for (n = 1; n < 250; n++)
{
token[n] = strtok(0, " "); // subsequent tokens
if (!token[n]) break; // no more tokens
}
//col2 = n;
}
// process (print) the tokens
for (int i = 0; i < n; i++){ // n = #of tokens
//cout << "Token[" << i << "] = " << token[i] << endl;
a1[dum1] = atof(token[i]);
//cout << check2[stat2] << endl;
dum1++;
}
//cout << endl;
}
}
while (!infile.eof())
{
char buffer[512];
infile.getline(buffer,512);
int n = 0;
// array to store memory addresses of the tokens in buf
const char* token[250] = {}; // initialize to 0
// parse the line
token[0] = strtok(buffer," "); // first token
if (token[0]) // zero if line is blank
{
for (n = 1; n < 250; n++)
{
token[n] = strtok(0, " "); // subsequent tokens
if (!token[n]) break; // no more tokens
}
//col1 = n;
}
// process (print) the tokens
for (int i = 0; i < n; i++){ // n = #of tokens
//cout << "Token[" << i << "] = " << token[i] << endl;
a2[dum2] = atof(token[i]);
//cout << check1[stat1] << endl;
dum2++;
}
//cout << endl;
if(infile.eof())
break;
}
//cout << stat1 << " " << col1 << " " << stat2 << " " << col2 << endl;
int newX,newY;
for(int i = 0;i < stat2 ;i++){
//cout << a1[i] << endl;
}
int ro1 = stat1/col1; int ro2 = stat2/col2;
newX = col1+col2-1;
newY = ro1+ro2-1;
dX=newX+col1-1;
dY=newY+ro1-1;
kY=ro1;
kX=col1;
//Padding input matrix such that the convolution formulae is valid for all values
//Host Input Vector
float *host_a;
//h_a = new float [dataSizeX*dataSizeY];
float *host_h;
//Host Output Vector
float *host_c;
//Device Input Vector
float *device_a;
float *device_h;
//Host output Vector
float *device_c;
//Memory allocation for Host
host_a = (float*)malloc((dX*dY)*sizeof(float));
host_h = (float*)malloc((kY*kX)*sizeof(float));
host_c = (float*)malloc((newX*newY)*sizeof(float));
//Memory allocation for device
cudaMalloc(&device_a, (dX*dY)*sizeof(float));
cudaMalloc(&device_h, (kY*kX)*sizeof(float));
cudaMalloc(&device_c, (newX*newY)*sizeof(float));
for(int i=0;i<dY;i++){
for(int j=0;j<dX;j++){
host_a[i*dX + j] = 0.0;
}
}
//Padding happens here on input matrix 2*(kY-1) rows added and 2*(kX-1) collumns added
//Intialize on Host
int set1 = kX-1;
int set2 = kY-1;
int countset = 0;
for(int i = set2;i <(dY-(kY-1)) ;i++){
for(int j=0;j < set1;j++){
host_a[i*dX + j] = 0.0;
}
for(int j = set1;j<(set1+col2);j++){
host_a[i*dX + j] = a1[countset];
countset++;
}
}
for(int i=0;i<(kY*kX);i++){
host_h[i] = a2[i];
}
//Transfer to device
cudaMemcpy( device_a, host_a, (dX*dY)*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy( device_h, host_h, (kY*kX)*sizeof(float), cudaMemcpyHostToDevice);
float x = newX;
float y = newY;
//Calculating GridSize required for computations
int sizingX = (int)ceil((float)((float)(x)/16));
int sizingY = (int)ceil((float)((float)(y)/16));
dim3 blockSize(16,16);
dim3 gridSize(sizingX,sizingY);
twodimconvol<<<gridSize, blockSize>>>(device_a, device_h, device_c, kY, kX,dY, dX,newX,newY);
// Copy array back to host
cudaMemcpy( host_c, device_c, (newX*newY)*sizeof(float), cudaMemcpyDeviceToHost );
// Release device memory
cudaFree(device_a);
cudaFree(device_h);
cudaFree(device_c);
int i,j;
for(int j=0;j<newY;j++){
for(int i=0;i<newX;i++){
cout << fixed << setprecision(1) << host_c[j*newX + i] << " ";
}
cout << endl;
}
// Release host memory
free(host_a);
free(host_h);
free(host_c);
return 0;
}
|
2,727 | //
// Created by igor on 26.03.2021.
//
#include "ColorF.cuh"
__host__ __device__ ColorF operator* (const ColorF &c, float f) {
return {c.r * f,
c.g * f,
c.b * f};
}
__host__ __device__ ColorF operator+ (const ColorF &l, const ColorF &r) {
return {l.r + r.r,
l.g + r.g,
l.b + r.b};
}
__host__ __device__ ColorF ColorF::operator+=(const ColorF &o) {
r += o.r;
g += o.g;
b += o.b;
return *this;
}
|
2,728 | #include <iostream>
#include <cuda_runtime.h>
using namespace std;
int main()
{
float * pDeviceData = nullptr;
int width = 10 * sizeof(float);
int height = 10 * sizeof(float);
size_t pitch;
cudaError err = cudaSuccess;
//1 use cudaMallocPitch function
err = cudaMallocPitch(&pDeviceData, &pitch, width, height); //עwidthheightĵλΪֽ
if (err != cudaSuccess)
{
cout << "call cudaMallocPitch fail!!!" << endl;
exit(1);
}
cout << "width: " << width << endl;
cout << "height: " << height << endl;
cout << "pitch: " << pitch << endl;
//2 use cudaMalloc3D
cudaPitchedPtr pitchPtr;
cudaExtent extent;
extent.width = 10 * sizeof(float);
extent.height = 22 * sizeof(float);
extent.depth = 33 * sizeof(float);
err = cudaMalloc3D(&pitchPtr, extent);
if (err != cudaSuccess)
{
cout << "call cudaMalloc3D fail!!!" << endl;
exit(1);
}
cout << "\n\n";
cout << "width: " << extent.width << endl; //ڴijʼֵ
cout << "height: " << extent.height << endl;
cout << "depth: " << extent.depth << endl;
cout << endl;
cout << "pitch: " << pitchPtr.pitch << endl; //ʵʵĿֵ
cout << "xsize: " << pitchPtr.xsize << endl; //Ч--extent.width
cout << "ysize: " << pitchPtr.ysize << endl; //Ч߶--extent.height
cudaFree(pDeviceData);
cudaFree(pitchPtr.ptr);
cin.get();
return 0;
}
|
2,729 | #include "fast_heap.h"
int main(int argc, const char *argv[]) {
HeapElement<HeapElementSpec> &elm = fast_heap->get(100);
elm.discard();
}
|
2,730 |
#include <iostream>
__global__ void simdtest(float* A) {
int globalID = blockIdx.x * blockDim.x + threadIdx.x;
if ( (threadIdx.x % 32) < 8 ) {
A[globalID] = 1;
} else {
A[globalID] = 0;
}
}
int main()
{
int THREADS = 256;
float* A;
cudaMallocManaged(&A, THREADS*sizeof(float));
std::cout << "launch" << std::endl;
simdtest<<< THREADS/256, 256 >>>(A);
cudaDeviceSynchronize();
std::cout << "A: ";
for ( int i = 0; i < THREADS; ++i) {
std::cout << A[i] << ", ";
}
std::cout << std::endl;
}
|
2,731 | #include <cuda_runtime.h>
#include <stdio.h>
__global__ void helloworld()
{
printf("hello world\n");
}
int main(int argc, char** argv)
{
// launch a gpu kernel
helloworld<<<3,3>>>();
// block the cpu for the gpu to finish execution
cudaDeviceSynchronize();
return 0;
}
|
2,732 | //MIT License
//Copyright (c) 2020 Sherman Lo
#include <cuda.h>
#include <curand_kernel.h>
//See empiricalNullFilter - this is the main entry
//Notes: row major
//Note: shared memory is used to store the empirical null mean and std. IF big
//enough, also the cache. Size becomes a problem if the kernel radius
//becomes too big, in this case, the cache lives in global memory and
//hopefully may be picked up in L1 and L2
//set cachePointerWidth = cacheWidth if isCopyCacheToShared is false
//set cachePointerWidth = blockDim.x + 2*kernelRadius if isCopyCacheToShared
//is true
__constant__ int roiWidth;
__constant__ int roiHeight;
__constant__ int cacheWidth;
__constant__ int kernelRadius;
__constant__ int kernelHeight;
__constant__ int nInitial; //number of initial values for Newton-Raphson
__constant__ int nStep; //number of steps for Newton-Raphson
__constant__ int cachePointerWidth; //the width of the shared memory cache
__constant__ int isCopyCacheToShared; //indicate to copy cache to shared mem
/**FUNCTION: Get derivative
* Set dxLnF to contain derivatives of the density estimate (of values in the
* kernel) evaluated at a point
* PARAMETERS:
* cachePointer: see empiricalNullFilter
* bandwidth: see findMode
* kernelPointers: see empiricalNullFilter
* value: where to evaluate the density estimate and the derivatives
* dxLnF: MODIFIED 3-element array, to store results. The elements are:
* 1. the density (ignore any constant multiplied to it) (NOT THE LOG)
* 2. the first derivative of the log density
* 3. the second derivative of the log density
*/
__device__ void getDLnDensity(float* cachePointer, float bandwidth,
int* kernelPointers, float* value, float* dxLnF) {
//variables when going through all pixels in the kernel
float z; //value of a pixel when looping through kernel
float sumKernel[3] = {0.0f}; //store sums of weights
float phiZ; //weight, use Gaussian kernel
//pointer for cacheShared
//point to the top left of the kernel
cachePointer -= kernelRadius*cachePointerWidth;
//for each row in the kernel
for (int i=0; i<2*kernelHeight; i++) {
//for each column for this row
for (int dx=kernelPointers[i++]; dx<=kernelPointers[i]; dx++) {
//append to sum if the value in cachePointer is finite
z = *(cachePointer+dx);
if (isfinite(z)) {
z -= *value;
z /= bandwidth;
phiZ = expf(-z*z/2);
sumKernel[0] += phiZ;
sumKernel[1] += phiZ * z;
sumKernel[2] += phiZ * z * z;
}
}
cachePointer += cachePointerWidth;
}
//work out derivatives
float normaliser = bandwidth*sumKernel[0];
dxLnF[0] = sumKernel[0];
dxLnF[1] = sumKernel[1] / normaliser;
dxLnF[2] = (sumKernel[0]*(sumKernel[2] - sumKernel[0])
- sumKernel[1]*sumKernel[1]) / (normaliser * normaliser);
}
/**FUNCTION: Find mode
* Use Newton-Raphson to find the maximum value of the density estimate. Uses
* the passed nullMean as the initial value and modifies it at each step,
* ending up with a final answer.
* The second derivative of the log density and the density (up to a constant)
* at the final answer is stored in secondDiffLn and densityAtMode.
* PARAMETERS:
* cachePointer: see empiricalNullFilter
* bandwidth: bandwidth for the density estimate
* kernelPointers: see empiricalNullFilter
* nullMean: MODIFIED initial value for the Newton-Raphson method, modified
* to contain the final answer
* secondDiffLn: MODIFIED second derivative of the log density
* RETURNS: true if sucessful, false otherwise
*/
__device__ bool findMode(float* cachePointer, float bandwidth,
int* kernelPointers,float* nullMean, float* secondDiffLn,
float* densityAtMode) {
float dxLnF[3];
//nStep of Newton-Raphson
for (int i=0; i<nStep; i++) {
getDLnDensity(cachePointer, bandwidth, kernelPointers, nullMean, dxLnF);
*nullMean -= dxLnF[1] / dxLnF[2];
}
getDLnDensity(cachePointer, bandwidth, kernelPointers, nullMean, dxLnF);
//need to check if answer is valid
if (isfinite(*nullMean) && isfinite(dxLnF[0]) && isfinite(dxLnF[1])
&& isfinite(dxLnF[2]) && (dxLnF[2] < 0)) {
*densityAtMode = dxLnF[0];
*secondDiffLn = dxLnF[2];
return true;
} else {
return false;
}
}
/**FUNCTION: COPY CACHE TO SHARED MEMORY
* Parameters:
* cachedShared: pointer to shared memory
* cache: pointer to cache
* kernelPointers: see empiricalNullFilter
*/
__device__ void copyCacheToSharedMemory(float* dest, float* source,
int* kernelPointers) {
//point to top left
dest -= kernelRadius*cachePointerWidth;
source -= kernelRadius*cacheWidth;
//for each row in the kernel
for (int i=0; i<2*kernelHeight; i++) {
//for each column for this row
for (int dx=kernelPointers[i++]; dx<=kernelPointers[i]; dx++) {
*(dest+dx) = *(source+dx);
}
source += cacheWidth;
dest += cachePointerWidth;
}
}
/**KERNEL: Empirical Null Filter
* Does the empirical null filter on the pixels in cache, giving the empirical
* null mean (aka mode) and the empirical null std.
* PARAMETERS:
* cache: array of pixels in the cache
* initialSigmaRoi: array of pixels (same size as the ROI) containing standard
* deviations, used for producing random initial values for Newton-Raphson
* bandwidthRoi: array of pixels (same size as the ROI) containing
* kernelPointers: array (even number of elements, size 2*kernelHeight)
* containing pairs of integers, indicates for each row the position from
* the centre of the kernel
* nullMeanRoi: MODIFIED array of pixels (same size as ROI), pass results of
* median filter here to be used as initial values. Modified to contain
* the empricial null mean afterwards.
* nullStdRoi: MODIFIED array of pixels (same size as ROI) to contain the
* empirical null std
* progressRoi: MODIFIED array of pixels (same size as ROI) initally contains
* all zeros. A filtered pixel will change it to a one.
*/
extern "C" __global__ void empiricalNullFilter(float* cache,
float* initialSigmaRoi, float* bandwidthRoi, int* kernelPointers,
float* nullMeanRoi, float* nullStdRoi, int* progressRoi) {
int x0 = threadIdx.x + blockIdx.x * blockDim.x;
int y0 = threadIdx.y + blockIdx.y * blockDim.y;
//adjust pointer to the corresponding x y coordinates
cache += (y0+kernelRadius)*cacheWidth + x0 + kernelRadius;
//check if in roi
//&&isfinite(*cache) is not required as accessing the cache from this
//pixel is within bounds
bool isInRoi = x0 < roiWidth && y0 < roiHeight;
//get shared memory
extern __shared__ float sharedMemory[];
float* nullMeanSharedPointer = sharedMemory;
float* secondDiffSharedPointer = nullMeanSharedPointer
+ blockDim.x * blockDim.y;
float* cachePointer;
//offset by the x and y coordinates
int roiIndex = y0*roiWidth + x0;
int nullSharedIndex = threadIdx.y*blockDim.x + threadIdx.x;
//if the shared memory is big enough, copy the cache
//cachePointer points to shared memory if shared memory allows it, otherwise
//points to global memory
if (isCopyCacheToShared) {
cachePointer = secondDiffSharedPointer + blockDim.x * blockDim.y;
cachePointer += (threadIdx.y+kernelRadius)*cachePointerWidth
+ threadIdx.x + kernelRadius;
//copy cache to shared memory
if (isInRoi) {
copyCacheToSharedMemory(cachePointer, cache, kernelPointers);
}
} else {
cachePointer = cache;
}
__syncthreads();
//adjust pointer to the corresponding x y coordinates
nullMeanSharedPointer += nullSharedIndex;
secondDiffSharedPointer += nullSharedIndex;
//for rng
curandState_t state;
curand_init(0, roiIndex, 0, &state);
//nullMean used to store mode for each initial value
float nullMean;
float median;
float sigma; //how much noise to add
float bandwidth; //bandwidth for density estimate
if (isInRoi) {
nullMean = nullMeanRoi[roiIndex]; //use median as first initial
median = nullMean;
//modes with highest densities are stored in shared memory
*nullMeanSharedPointer = nullMean;
sigma = initialSigmaRoi[roiIndex]; //how much noise to add
bandwidth = bandwidthRoi[roiIndex]; //bandwidth for density estimate
}
bool isSuccess; //indiciate if newton-raphson was sucessful
float densityAtMode; //density for this particular mode
//second derivative of the log density, to set empirical null std
float secondDiffLn;
//keep solution with the highest density
float maxDensityAtMode = -INFINITY;
//try different initial values, the first one is the median, then add
//normal noise neighbouring shared memory nullMean for different
//initial values rotate from -1, itself and +1 from current pointer
int min;
int nNeighbour;
float initial0;
if (nullSharedIndex == 0) {
min = 0;
} else {
min = -1;
}
if (nullSharedIndex == blockDim.x*blockDim.y - 1) {
nNeighbour = 1 - min;
} else {
nNeighbour = 2 - min;
}
for (int i=0; i<nInitial; i++) {
if (isInRoi) {
isSuccess = findMode(cachePointer, bandwidth, kernelPointers, &nullMean,
&secondDiffLn, &densityAtMode);
//keep nullMean and nullStd with the highest density
if (isSuccess) {
if (densityAtMode > maxDensityAtMode) {
maxDensityAtMode = densityAtMode;
*nullMeanSharedPointer = nullMean;
*secondDiffSharedPointer = secondDiffLn;
}
}
}
//try different initial value
__syncthreads();
if (isInRoi) {
initial0 = *(nullMeanSharedPointer + i%nNeighbour + min);
//ensure the initial value is finite, otherwise use previous solution
if (!isfinite(initial0)) {
initial0 = nullMean;
}
nullMean = (initial0 + median)/2 + sigma * curand_normal(&state);
}
}
//store final results
if (isInRoi) {
nullMeanRoi[roiIndex] = *nullMeanSharedPointer;
nullStdRoi[roiIndex] = powf(-*secondDiffSharedPointer, -0.5f);
progressRoi[roiIndex] = 1;
}
}
|
2,733 | #ifndef _Vector3D_
#define _Vector3D_
#include <math.h>
#include <limits>
class Vector3D
{
public:
float x;
float y;
float z;
__host__ __device__ Vector3D()
{
}
__host__ __device__ Vector3D(float x, float y, float z)
{
this->x = x;
this->y = y;
this->z = z;
}
__host__ __device__ ~Vector3D()
{
}
__host__ __device__ Vector3D operator+(Vector3D vec)
{
Vector3D result;
result.x = x + vec.x;
result.y = y + vec.y;
result.z = z + vec.z;
return result;
}
__host__ __device__ Vector3D operator-(Vector3D vec)
{
Vector3D result;
result.x = x - vec.x;
result.y = y - vec.y;
result.z = z - vec.z;
return result;
}
__host__ __device__ Vector3D operator*(float factor)
{
Vector3D result;
result.x = x * factor;
result.y = y * factor;
result.z = z * factor;
return result;
}
__host__ __device__ Vector3D operator/(float div)
{
Vector3D result;
result.x = x / div;
result.y = y / div;
result.z = z / div;
return result;
}
__host__ __device__ Vector3D operator += (float b)
{
x += b;
y += b;
z += b;
return *this;
}
__host__ __device__ Vector3D operator /= (float c)
{
x /= c;
y /= c;
z /= c;
return *this;
}
__host__ __device__ Vector3D operator *= (float d)
{
x *= d;
y *= d;
z *= d;
return *this;
}
__host__ __device__ float length()
{
return sqrt(x*x + y*y);
}
/*Vector3D rotate(float angle)
{
Vector3D result;
result.x = x * cos(angle) + y * sin(angle);
result.y = -1 * x * sin(angle) + y * cos(angle);
return result;
}*/
__host__ __device__ inline void Normalize()
{
float vector_length = this->length();
//if (vector_length > std::numeric_limits<float>::epsilon())
//{
this->x /= vector_length;
this->y /= vector_length;
this->z /= vector_length;
//}
}
__device__ Vector3D truncVector(Vector3D vector3, float max)
{
if(vector3.length() > max)
{
vector3.Normalize();
vector3 *= max;
}
return vector3;
}
};
#endif |
2,734 | #include <stdint.h>
#include <cuda.h>
extern "C"
__global__
void idle(unsigned int *p, unsigned int n)
{
int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;
unsigned int i = 0, j = 0, k = 0;
__shared__ int s;
s = *p;
if (x == 0 && y == 0) {
for (i = 0; i < n; i++) {
if (x + y > n) {
s = s + x;
if (s > x + y)
s = x;
}
}
}
*p = s;
}
|
2,735 | /**
* Autor: Grupo GRID
* Fecha: Julio 2016
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 4
#define _BLOCK_SIZE_ 2
__global__ void MultiplocarMatrices(int *A, int *B, int *C, int n)
{
const uint wA = n;
const uint wB = n;
const uint bx = blockIdx.x;
const uint by = blockIdx.y;
const uint tx = threadIdx.x;
const uint ty = threadIdx.y;
const uint aBegin = wA * _BLOCK_SIZE_ * by;
const uint aEnd = aBegin + wA - 1;
const uint aStep = _BLOCK_SIZE_;
const uint bBegin = _BLOCK_SIZE_ * bx;
const uint bStep = _BLOCK_SIZE_ * wB;
float Csub = 0;
for (int a = aBegin, b = bBegin;
a <= aEnd;
a += aStep, b += bStep)
{
__shared__ float As[_BLOCK_SIZE_][_BLOCK_SIZE_];
__shared__ float Bs[_BLOCK_SIZE_][_BLOCK_SIZE_];
As[ty][tx] = A[a + wA * ty + tx];
Bs[ty][tx] = B[b + wB * ty + tx];
__syncthreads();
for (int k = 0; k < _BLOCK_SIZE_; ++k)
Csub += As[ty][k] * Bs[k][tx];
__syncthreads();
}
const uint c = wB * _BLOCK_SIZE_ * by + _BLOCK_SIZE_ * bx;
C[c + wB * ty + tx] = Csub;
}
int main( int argc, char** argv)
{
int *h_a, *h_b, *h_c;
int *d_a, *d_b, *d_c;
char validacion[10];
int n = N; // Valor por defecto
if ( argc > 1 )
{
n = atoi (argv[1]);
if ( n > 1024 )
{
n = 1024;
}
}
size_t memSize = n * n * sizeof( int );
h_a = (int *) malloc( memSize );
h_b = (int *) malloc( memSize );
h_c = (int *) malloc( memSize );
if ( h_a == NULL || h_b == NULL || h_c == NULL )
{
perror("Memoria insuficiente\n");
exit(-1);
}
cudaMalloc( (void**) &d_a, memSize );
cudaMalloc( (void**) &d_b, memSize );
cudaMalloc( (void**) &d_c, memSize );
if ( d_a == NULL || d_b == NULL || d_c == NULL )
{
perror("Memoria insuficiente en la GPU\n");
exit(-1);
}
for( int i = 0 ; i < n ; i++ )
{
for( int j = 0 ; j < n ; j++ )
{
h_a[ n * i + j] = 1;
h_b[ n * i + j] = 1;
h_c[ n * i + j] = 0;
}
}
cudaMemcpy( d_a, h_a , memSize, cudaMemcpyHostToDevice );
cudaMemcpy( d_b, h_b , memSize, cudaMemcpyHostToDevice );
int MATRIX_SIZE = n;
int TILE_SIZE = 2;
dim3 dimGrid ( MATRIX_SIZE / TILE_SIZE, MATRIX_SIZE / TILE_SIZE);
dim3 dimBlock (TILE_SIZE, TILE_SIZE, 1);
MultiplocarMatrices<<< dimGrid , dimBlock >>> (d_a, d_b, d_c, n );
cudaMemcpy( h_c, d_c, memSize, cudaMemcpyDeviceToHost );
// Validación de la multiplicación
// El producto de dos matrices de NxN de unos produce una matriz donde todos los elementos son N
strcpy(validacion, "Ok");
for( int i = 0 ; i < n ; i++ )
{
for( int j = 0 ; j < n ; j++ )
{
if ( h_c[ n * i + j ] != n )
{
strcpy(validacion, "Error");
}
}
}
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
free(h_a);
free(h_b);
free(h_c);
printf ( "\t %10d \t\t %s \t ", n, validacion );
return 0;
}
|
2,736 | #include "includes.h"
__global__ void vectorAddKernel(float* inputA, float* inputB, float* output, int length){
//compute element index
int idx = blockIdx.x * blockDim.x + threadIdx.x;
//add an vector element
if(idx < length) output[idx] = inputA[idx] + inputB[idx];
} |
2,737 | #include "nodes-list.hh"
#include "node.hh"
#include <algorithm>
#include <cassert>
#include <map>
namespace rt
{
namespace
{
std::vector<Node*> preds_no_not(Node* n)
{
std::vector<Node*> res;
for (auto pred : n->preds)
{
if (pred->type == Node::OP_NOP)
{
auto rpreds = preds_no_not(pred);
res.insert(res.end(), rpreds.begin(), rpreds.end());
}
else
res.push_back(pred);
}
return res;
}
std::string tensor_name(const dbl_t* ptr,
std::map<const dbl_t*, std::string>& map)
{
auto it = map.find(ptr);
if (it != map.end())
return it->second;
auto name = "t" + std::to_string(map.size());
map[ptr] = name;
return name;
}
}
NodesList::NodesList(const std::vector<Node*> nodes)
{
for (auto n : nodes)
if (n->type != Node::OP_NOP)
nodes_.push_back(n);
for (auto n : nodes_)
{
auto ppreds = preds_no_not(n);
std::vector<std::size_t> npreds;
for (auto p : ppreds)
{
auto it = std::find(nodes_.begin(), nodes_.end(), p);
assert(it != nodes_.end());
npreds.push_back(std::distance(nodes_.begin(), it));
}
preds_.push_back(npreds);
}
}
std::size_t NodesList::size() const
{
return nodes_.size();
}
const std::vector<Node*>& NodesList::nodes() const
{
return nodes_;
}
const std::vector<std::vector<std::size_t>>& NodesList::preds() const
{
return preds_;
}
std::ostream& operator<<(std::ostream& os, const NodesList& list)
{
auto& vals = list.nodes();
std::map<const dbl_t*, std::string> tmap;
for (std::size_t i = 0; i < vals.size(); ++i)
{
auto node = vals[i];
os << i << ": ";
os << Node::OP_NAMES[node->type];
os << " (" << tensor_name(node->out1, tmap);
if (node->out2)
os << ", " << tensor_name(node->out2, tmap);
os << ") <= (" << tensor_name(node->in1, tmap);
if (node->in2)
os << ", " << tensor_name(node->in2, tmap) ;
if (node->in3)
os << ", " << tensor_name(node->in3, tmap);
os << ") ";
os << "{" << node->len1;
if (node->len2)
os << ", " << node->len2;
if (node->len3)
os << ", " << node->len3;
os << "} ";
os << "[";
auto& preds = list.preds()[i];
for (std::size_t i = 0; i < preds.size(); ++i)
{
os << preds[i];
if (i + 1 != preds.size())
os << ", ";
}
os << "]";
os << std::endl;
}
return os;
}
}
|
2,738 | /*
* EzUpdater.cpp
*
* Created on: 25 янв. 2016 г.
* Author: aleksandr
*/
#include "EzUpdater.h"
#include "SmartIndex.h"
// indx - индекс вдоль правой или левой границы по y от firstY до lastY
__host__ __device__
void EzUpdater::operator() (const int indx) {
/* correct Ez adjacent to TFSF boundary */
// correct Ez field along left edge
// mm = firstX;
// for (nn = firstY; nn <= lastY; nn++)
// Ez(mm, nn) -= Cezh(mm, nn) * Hy1G(g1, mm - 1);
//
// // correct Ez field along right edge
// mm = lastX;
// for (nn = firstY; nn <= lastY; nn++)
// Ez(mm, nn) += Cezh(mm, nn) * Hy1G(g1, mm);
float Cezh = S*377.0;
int m = firstX;
Ez(m, indx) = Ez(m, indx) - Cezh * Hy1D[m-1];
m = lastX;
Ez(m, indx) = Ez(m, indx) + Cezh * Hy1D[m];
}
|
2,739 | extern "C" {
typedef struct {
int e0;
char* e1;
} struct_Buffer_220119;
typedef struct {
struct_Buffer_220119 e0;
int e1;
int e2;
int e3;
} struct_Img_220118;
union variant_220130 {
int qs32;
float pf32;
};
typedef struct {
unsigned int e0;
union variant_220130 e1;
} struct_BoundaryMode_220129;
__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_1008134(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_996460(float*, float*, int);
__global__ void lambda_1009614(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1019920(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_999197(float*, float*, int, int);
__global__ void lambda_1016068(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1031454(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1036899(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1034051(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1011990(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1011628(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_999837(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1006659(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1014598(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1043829(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1007129(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1002689(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1032459(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1043283(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_998005(float*, float*, int, int);
__global__ void lambda_1033049(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1016430(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1027205(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1025365(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1041691(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1045126(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1016900(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1001392(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1006297(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1033592(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1003694(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1024819(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1039389(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1034597(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1027667(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1019376(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1014055(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1022765(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1005832(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1025830(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1044656(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1022222(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1026192(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_998397(float*, float*, int);
__global__ void lambda_1003232(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1007672(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1029152(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1035062(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1010617(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1000387(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_998812(float*, float*, int);
__global__ void lambda_1037483(struct_Img_220118, struct_Img_220118, float*, float*);
__global__ void lambda_997261(float*, float*, int);
__global__ void lambda_1040216(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1038384(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1020379(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1013003(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1005286(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1000846(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1012460(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1004827(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1029611(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1028609(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1008735(float*, struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118);
__global__ void lambda_1017443(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1036437(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1021752(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1024360(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1011163(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1040686(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1021390(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_997650(float*, float*, int);
__global__ void lambda_996843(float*, float*, int, int);
__global__ void lambda_1035894(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1046131(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1010158(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1042281(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1042824(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1013465(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1039854(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1018505(float*, float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118);
__global__ void lambda_1015603(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_995956(float*, float*, int);
__global__ void lambda_1044294(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1035424(float*, struct_Img_220118, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1030984(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1015057(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1045669(float*, struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1030157(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1041229(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1017905(struct_Img_220118, float*, struct_Img_220118, float*, struct_Img_220118, float*);
__global__ void lambda_1002219(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1038843(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1020925(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1031997(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1001857(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1037841(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1030622(struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118, float*);
__global__ void lambda_1028251(float*, float*, struct_Img_220118, struct_Img_220118);
__global__ void lambda_1023817(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1026662(struct_Img_220118, float*, struct_Img_220118, float*, float*, struct_Img_220118);
__global__ void lambda_1004284(struct_Img_220118, struct_Img_220118, float*, struct_Img_220118, float*, float*);
__global__ void lambda_1023227(float*, struct_Img_220118, float*, float*, struct_Img_220118, struct_Img_220118);
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1008134(struct_Img_220118 _1008137_1270052, struct_Img_220118 _1008138_1270053, float* _1008139_1270054, struct_Img_220118 _1008140_1270055, float* _1008141_1270056, float* _1008142_1270057) {
int _1270060;
int p_1270060;
int _1270063;
int p_1270063;
int _1270066;
int p_1270066;
int _1270069;
int p_1270069;
int _1270072;
int p_1270072;
int _1270075;
int p_1270075;
int _1270078;
int p_1270078;
struct_BoundaryMode_220129 bh_upper_1270089;
struct_BoundaryMode_220129 pbh_upper_1270089;
struct_BoundaryMode_220129 bh_upper_1270100;
struct_BoundaryMode_220129 pbh_upper_1270100;
float _1270117;
float p_1270117;
float _1270120;
float p_1270120;
struct_BoundaryMode_220129 bh_upper_1270124;
struct_BoundaryMode_220129 pbh_upper_1270124;
struct_BoundaryMode_220129 bh_upper_1270130;
struct_BoundaryMode_220129 pbh_upper_1270130;
float _1270146;
float p_1270146;
float _1270149;
float p_1270149;
struct_BoundaryMode_220129 bh_upper_1270155;
struct_BoundaryMode_220129 pbh_upper_1270155;
struct_BoundaryMode_220129 bh_upper_1270159;
struct_BoundaryMode_220129 pbh_upper_1270159;
float _1270175;
float p_1270175;
float _1270178;
float p_1270178;
struct_BoundaryMode_220129 bh_upper_1270184;
struct_BoundaryMode_220129 pbh_upper_1270184;
struct_BoundaryMode_220129 bh_upper_1270188;
struct_BoundaryMode_220129 pbh_upper_1270188;
float _1270204;
float p_1270204;
float _1270207;
float p_1270207;
struct_BoundaryMode_220129 bh_upper_1270211;
struct_BoundaryMode_220129 pbh_upper_1270211;
struct_BoundaryMode_220129 bh_upper_1270217;
struct_BoundaryMode_220129 pbh_upper_1270217;
float _1270233;
float p_1270233;
float _1270236;
float p_1270236;
_1270060 = threadIdx_x();
p_1270060 = _1270060;
l1270058: ;
_1270060 = p_1270060;
_1270063 = blockDim_x();
p_1270063 = _1270063;
l1270061: ;
_1270063 = p_1270063;
_1270066 = blockIdx_x();
p_1270066 = _1270066;
l1270064: ;
_1270066 = p_1270066;
_1270069 = threadIdx_y();
p_1270069 = _1270069;
l1270067: ;
_1270069 = p_1270069;
_1270072 = blockDim_y();
p_1270072 = _1270072;
l1270070: ;
_1270072 = p_1270072;
_1270075 = blockIdx_y();
p_1270075 = _1270075;
l1270073: ;
_1270075 = p_1270075;
_1270078 = blockDim_y();
p_1270078 = _1270078;
l1270076: ;
_1270078 = p_1270078;
int _1270080;
_1270080 = _1008137_1270052.e1;
int _1270081;
_1270081 = _1270080 - 128;
int _1270079;
_1270079 = _1008138_1270053.e1;
int _1270083;
_1270083 = _1270063 * _1270066;
int _1270082;
_1270082 = _1270081 + _1270060;
int gid_x_1270084;
gid_x_1270084 = _1270082 + _1270083;
union variant_220130 _1270273;
_1270273.qs32 = gid_x_1270084;
bool _1270085;
_1270085 = _1270079 <= gid_x_1270084;
struct_BoundaryMode_220129 _1270274;
_1270274.e0 = 0;
_1270274.e1 = _1270273;
if (_1270085) goto l1270086; else goto l1270327;
l1270327: ;
pbh_upper_1270089 = _1270274;
goto l1270087;
l1270086: ;
union variant_220130 _1265919_6;
_1265919_6.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8;
_1265920_8.e0 = 1;
_1265920_8.e1 = _1265919_6;
pbh_upper_1270089 = _1265920_8;
goto l1270087;
l1270087: ;
bh_upper_1270089 = pbh_upper_1270089;
int _1270094;
_1270094 = _1270072 * _1270075;
int _1270090;
_1270090 = _1008138_1270053.e2;
int _1270091;
_1270091 = _1008137_1270052.e2;
int _1270092;
_1270092 = _1270091 - 1;
int _1270093;
_1270093 = _1270092 + _1270069;
int gid_y_1270095;
gid_y_1270095 = _1270093 + _1270094;
union variant_220130 _1270285;
_1270285.qs32 = gid_y_1270095;
bool _1270096;
_1270096 = _1270090 <= gid_y_1270095;
struct_BoundaryMode_220129 _1270286;
_1270286.e0 = 0;
_1270286.e1 = _1270285;
if (_1270096) goto l1270097; else goto l1270326;
l1270326: ;
pbh_upper_1270100 = _1270286;
goto l1270098;
l1270097: ;
union variant_220130 _1265919_18;
_1265919_18.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_20;
_1265920_20.e0 = 1;
_1265920_20.e1 = _1265919_18;
pbh_upper_1270100 = _1265920_20;
goto l1270098;
l1270098: ;
bh_upper_1270100 = pbh_upper_1270100;
union variant_220130 _1270111;
_1270111 = bh_upper_1270089.e1;
union variant_220130 _1270107;
_1270107 = bh_upper_1270100.e1;
unsigned int _1270101;
_1270101 = bh_upper_1270089.e0;
unsigned int _1270103;
_1270103 = bh_upper_1270100.e0;
int _1270109;
_1270109 = _1008138_1270053.e3;
bool _1270102;
_1270102 = _1270101 == 0;
bool _1270104;
_1270104 = _1270103 == 0;
bool _1270105;
_1270105 = _1270102 & _1270104;
if (_1270105) goto l1270106; else goto l1270317;
l1270317: ;
bool _1270318;
_1270318 = _1270101 == 1;
if (_1270318) goto l1270319; else goto l1270321;
l1270321: ;
bool _1270322;
_1270322 = _1270103 == 1;
if (_1270322) goto l1270323; else goto l1270325;
l1270325: ;
// bottom: float r4_1265918_33;
// bottom: p_1270120 = r4_1265918_33;
goto l1270118;
l1270323: ;
float c_1270324;
c_1270324 = _1270107.pf32;
p_1270120 = c_1270324;
goto l1270118;
l1270319: ;
float c_1270320;
c_1270320 = _1270111.pf32;
p_1270120 = c_1270320;
goto l1270118;
l1270106: ;
int y_1270108;
y_1270108 = _1270107.qs32;
int _1270110;
_1270110 = y_1270108 * _1270109;
int x_1270112;
x_1270112 = _1270111.qs32;
int _1270113;
_1270113 = _1270110 + x_1270112;
float* idx_1270114;
idx_1270114 = _1008139_1270054 + _1270113;
_1270117 = __ldg(idx_1270114);
p_1270117 = _1270117;
l1270115: ;
_1270117 = p_1270117;
p_1270120 = _1270117;
goto l1270118;
l1270118: ;
_1270120 = p_1270120;
int _1270242;
_1270242 = _1008140_1270055.e3;
int _1270243;
_1270243 = gid_y_1270095 * _1270242;
int _1270244;
_1270244 = _1270243 + gid_x_1270084;
float* idx_1270245;
idx_1270245 = _1008142_1270057 + _1270244;
float _1270246;
_1270246 = *idx_1270245;
if (_1270085) goto l1270121; else goto l1270316;
l1270316: ;
pbh_upper_1270124 = _1270274;
goto l1270122;
l1270121: ;
union variant_220130 _1265919_35;
_1265919_35.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_37;
_1265920_37.e0 = 1;
_1265920_37.e1 = _1265919_35;
pbh_upper_1270124 = _1265920_37;
goto l1270122;
l1270122: ;
bh_upper_1270124 = pbh_upper_1270124;
int _1270125;
_1270125 = -1 + gid_y_1270095;
bool _1270126;
_1270126 = _1270090 <= _1270125;
if (_1270126) goto l1270127; else goto l1270312;
l1270312: ;
union variant_220130 _1270313;
_1270313.qs32 = _1270125;
struct_BoundaryMode_220129 _1270314;
_1270314.e0 = 0;
_1270314.e1 = _1270313;
pbh_upper_1270130 = _1270314;
goto l1270128;
l1270127: ;
union variant_220130 _1265919_45;
_1265919_45.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_47;
_1265920_47.e0 = 1;
_1265920_47.e1 = _1265919_45;
pbh_upper_1270130 = _1265920_47;
goto l1270128;
l1270128: ;
bh_upper_1270130 = pbh_upper_1270130;
union variant_220130 _1270137;
_1270137 = bh_upper_1270130.e1;
unsigned int _1270131;
_1270131 = bh_upper_1270124.e0;
unsigned int _1270133;
_1270133 = bh_upper_1270130.e0;
union variant_220130 _1270140;
_1270140 = bh_upper_1270124.e1;
bool _1270132;
_1270132 = _1270131 == 0;
bool _1270134;
_1270134 = _1270133 == 0;
bool _1270135;
_1270135 = _1270132 & _1270134;
if (_1270135) goto l1270136; else goto l1270303;
l1270303: ;
bool _1270304;
_1270304 = _1270131 == 1;
if (_1270304) goto l1270305; else goto l1270307;
l1270307: ;
bool _1270308;
_1270308 = _1270133 == 1;
if (_1270308) goto l1270309; else goto l1270311;
l1270311: ;
// bottom: float r4_1265918_59;
// bottom: p_1270149 = r4_1265918_59;
goto l1270147;
l1270309: ;
float c_1270310;
c_1270310 = _1270137.pf32;
p_1270149 = c_1270310;
goto l1270147;
l1270305: ;
float c_1270306;
c_1270306 = _1270140.pf32;
p_1270149 = c_1270306;
goto l1270147;
l1270136: ;
int x_1270141;
x_1270141 = _1270140.qs32;
int y_1270138;
y_1270138 = _1270137.qs32;
int _1270139;
_1270139 = y_1270138 * _1270109;
int _1270142;
_1270142 = _1270139 + x_1270141;
float* idx_1270143;
idx_1270143 = _1008139_1270054 + _1270142;
_1270146 = __ldg(idx_1270143);
p_1270146 = _1270146;
l1270144: ;
_1270146 = p_1270146;
p_1270149 = _1270146;
goto l1270147;
l1270147: ;
_1270149 = p_1270149;
int _1270150;
_1270150 = -1 + gid_x_1270084;
bool _1270151;
_1270151 = _1270079 <= _1270150;
if (_1270151) goto l1270152; else goto l1270300;
l1270300: ;
union variant_220130 _1270301;
_1270301.qs32 = _1270150;
struct_BoundaryMode_220129 _1270302;
_1270302.e0 = 0;
_1270302.e1 = _1270301;
pbh_upper_1270155 = _1270302;
goto l1270153;
l1270152: ;
union variant_220130 _1265919_64;
_1265919_64.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_66;
_1265920_66.e0 = 1;
_1265920_66.e1 = _1265919_64;
pbh_upper_1270155 = _1265920_66;
goto l1270153;
l1270153: ;
bh_upper_1270155 = pbh_upper_1270155;
if (_1270096) goto l1270156; else goto l1270299;
l1270299: ;
pbh_upper_1270159 = _1270286;
goto l1270157;
l1270156: ;
union variant_220130 _1265919_70;
_1265919_70.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_72;
_1265920_72.e0 = 1;
_1265920_72.e1 = _1265919_70;
pbh_upper_1270159 = _1265920_72;
goto l1270157;
l1270157: ;
bh_upper_1270159 = pbh_upper_1270159;
unsigned int _1270162;
_1270162 = bh_upper_1270159.e0;
union variant_220130 _1270169;
_1270169 = bh_upper_1270155.e1;
bool _1270163;
_1270163 = _1270162 == 0;
unsigned int _1270160;
_1270160 = bh_upper_1270155.e0;
bool _1270161;
_1270161 = _1270160 == 0;
bool _1270164;
_1270164 = _1270161 & _1270163;
union variant_220130 _1270166;
_1270166 = bh_upper_1270159.e1;
if (_1270164) goto l1270165; else goto l1270290;
l1270290: ;
bool _1270291;
_1270291 = _1270160 == 1;
if (_1270291) goto l1270292; else goto l1270294;
l1270294: ;
bool _1270295;
_1270295 = _1270162 == 1;
if (_1270295) goto l1270296; else goto l1270298;
l1270298: ;
// bottom: float r4_1265918_84;
// bottom: p_1270178 = r4_1265918_84;
goto l1270176;
l1270296: ;
float c_1270297;
c_1270297 = _1270166.pf32;
p_1270178 = c_1270297;
goto l1270176;
l1270292: ;
float c_1270293;
c_1270293 = _1270169.pf32;
p_1270178 = c_1270293;
goto l1270176;
l1270165: ;
int x_1270170;
x_1270170 = _1270169.qs32;
int y_1270167;
y_1270167 = _1270166.qs32;
int _1270168;
_1270168 = y_1270167 * _1270109;
int _1270171;
_1270171 = _1270168 + x_1270170;
float* idx_1270172;
idx_1270172 = _1008139_1270054 + _1270171;
_1270175 = __ldg(idx_1270172);
p_1270175 = _1270175;
l1270173: ;
_1270175 = p_1270175;
p_1270178 = _1270175;
goto l1270176;
l1270176: ;
_1270178 = p_1270178;
int _1270179;
_1270179 = 1 + gid_x_1270084;
bool _1270180;
_1270180 = _1270079 <= _1270179;
if (_1270180) goto l1270181; else goto l1270287;
l1270287: ;
union variant_220130 _1270288;
_1270288.qs32 = _1270179;
struct_BoundaryMode_220129 _1270289;
_1270289.e0 = 0;
_1270289.e1 = _1270288;
pbh_upper_1270184 = _1270289;
goto l1270182;
l1270181: ;
union variant_220130 _1265919_89;
_1265919_89.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_91;
_1265920_91.e0 = 1;
_1265920_91.e1 = _1265919_89;
pbh_upper_1270184 = _1265920_91;
goto l1270182;
l1270182: ;
bh_upper_1270184 = pbh_upper_1270184;
if (_1270096) goto l1270185; else goto l1270284;
l1270284: ;
pbh_upper_1270188 = _1270286;
goto l1270186;
l1270185: ;
union variant_220130 _1265919_95;
_1265919_95.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_97;
_1265920_97.e0 = 1;
_1265920_97.e1 = _1265919_95;
pbh_upper_1270188 = _1265920_97;
goto l1270186;
l1270186: ;
bh_upper_1270188 = pbh_upper_1270188;
unsigned int _1270191;
_1270191 = bh_upper_1270188.e0;
union variant_220130 _1270198;
_1270198 = bh_upper_1270184.e1;
union variant_220130 _1270195;
_1270195 = bh_upper_1270188.e1;
unsigned int _1270189;
_1270189 = bh_upper_1270184.e0;
bool _1270192;
_1270192 = _1270191 == 0;
bool _1270190;
_1270190 = _1270189 == 0;
bool _1270193;
_1270193 = _1270190 & _1270192;
if (_1270193) goto l1270194; else goto l1270275;
l1270275: ;
bool _1270276;
_1270276 = _1270189 == 1;
if (_1270276) goto l1270277; else goto l1270279;
l1270279: ;
bool _1270280;
_1270280 = _1270191 == 1;
if (_1270280) goto l1270281; else goto l1270283;
l1270283: ;
// bottom: float r4_1265918_109;
// bottom: p_1270207 = r4_1265918_109;
goto l1270205;
l1270281: ;
float c_1270282;
c_1270282 = _1270195.pf32;
p_1270207 = c_1270282;
goto l1270205;
l1270277: ;
float c_1270278;
c_1270278 = _1270198.pf32;
p_1270207 = c_1270278;
goto l1270205;
l1270194: ;
int x_1270199;
x_1270199 = _1270198.qs32;
int y_1270196;
y_1270196 = _1270195.qs32;
int _1270197;
_1270197 = y_1270196 * _1270109;
int _1270200;
_1270200 = _1270197 + x_1270199;
float* idx_1270201;
idx_1270201 = _1008139_1270054 + _1270200;
_1270204 = __ldg(idx_1270201);
p_1270204 = _1270204;
l1270202: ;
_1270204 = p_1270204;
p_1270207 = _1270204;
goto l1270205;
l1270205: ;
_1270207 = p_1270207;
if (_1270085) goto l1270208; else goto l1270272;
l1270272: ;
pbh_upper_1270211 = _1270274;
goto l1270209;
l1270208: ;
union variant_220130 _1265919_110;
_1265919_110.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_112;
_1265920_112.e0 = 1;
_1265920_112.e1 = _1265919_110;
pbh_upper_1270211 = _1265920_112;
goto l1270209;
l1270209: ;
bh_upper_1270211 = pbh_upper_1270211;
int _1270212;
_1270212 = 1 + gid_y_1270095;
bool _1270213;
_1270213 = _1270090 <= _1270212;
if (_1270213) goto l1270214; else goto l1270269;
l1270269: ;
union variant_220130 _1270270;
_1270270.qs32 = _1270212;
struct_BoundaryMode_220129 _1270271;
_1270271.e0 = 0;
_1270271.e1 = _1270270;
pbh_upper_1270217 = _1270271;
goto l1270215;
l1270214: ;
union variant_220130 _1265919_120;
_1265919_120.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_122;
_1265920_122.e0 = 1;
_1265920_122.e1 = _1265919_120;
pbh_upper_1270217 = _1265920_122;
goto l1270215;
l1270215: ;
bh_upper_1270217 = pbh_upper_1270217;
union variant_220130 _1270227;
_1270227 = bh_upper_1270211.e1;
unsigned int _1270220;
_1270220 = bh_upper_1270217.e0;
unsigned int _1270218;
_1270218 = bh_upper_1270211.e0;
union variant_220130 _1270224;
_1270224 = bh_upper_1270217.e1;
bool _1270221;
_1270221 = _1270220 == 0;
bool _1270219;
_1270219 = _1270218 == 0;
bool _1270222;
_1270222 = _1270219 & _1270221;
if (_1270222) goto l1270223; else goto l1270260;
l1270260: ;
bool _1270261;
_1270261 = _1270218 == 1;
if (_1270261) goto l1270262; else goto l1270264;
l1270264: ;
bool _1270265;
_1270265 = _1270220 == 1;
if (_1270265) goto l1270266; else goto l1270268;
l1270268: ;
// bottom: float r4_1265918_134;
// bottom: p_1270236 = r4_1265918_134;
goto l1270234;
l1270266: ;
float c_1270267;
c_1270267 = _1270224.pf32;
p_1270236 = c_1270267;
goto l1270234;
l1270262: ;
float c_1270263;
c_1270263 = _1270227.pf32;
p_1270236 = c_1270263;
goto l1270234;
l1270223: ;
int y_1270225;
y_1270225 = _1270224.qs32;
int x_1270228;
x_1270228 = _1270227.qs32;
int _1270226;
_1270226 = y_1270225 * _1270109;
int _1270229;
_1270229 = _1270226 + x_1270228;
float* idx_1270230;
idx_1270230 = _1008139_1270054 + _1270229;
_1270233 = __ldg(idx_1270230);
p_1270233 = _1270233;
l1270231: ;
_1270233 = p_1270233;
p_1270236 = _1270233;
goto l1270234;
l1270234: ;
_1270236 = p_1270236;
int _1270237;
_1270237 = _1008137_1270052.e3;
int _1270238;
_1270238 = gid_y_1270095 * _1270237;
float _1270256;
_1270256 = 2.500000e-01f * _1270236;
float _1270250;
_1270250 = 2.500000e-01f * _1270149;
float _1270252;
_1270252 = 2.500000e-01f * _1270178;
float _1270254;
_1270254 = 2.500000e-01f * _1270207;
float _1270241;
_1270241 = 2.000000e-01f * _1270120;
float _1270247;
_1270247 = _1270246;
int _1270239;
_1270239 = _1270238 + gid_x_1270084;
float _1270251;
_1270251 = 0.000000e+00f + _1270250;
float _1270253;
_1270253 = _1270251 + _1270252;
float _1270255;
_1270255 = _1270253 + _1270254;
float _1270248;
_1270248 = 2.000000e-01f * _1270247;
float* idx_1270240;
idx_1270240 = _1008141_1270056 + _1270239;
float _1270257;
_1270257 = _1270255 + _1270256;
float _1270249;
_1270249 = _1270241 + _1270248;
float val_1270258;
val_1270258 = _1270249 + _1270257;
*idx_1270240 = val_1270258;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_996460(float* _996463_1273486, float* _996464_1273487, int _996465_1273488) {
int _1273491;
int p_1273491;
int _1273494;
int p_1273494;
int _1273497;
int p_1273497;
int _1273500;
int p_1273500;
int _1273503;
int p_1273503;
int _1273506;
int p_1273506;
int _1273509;
int p_1273509;
int converge_1273515;
int pconverge_1273515;
float _1273523;
float p_1273523;
int converge_1273528;
int pconverge_1273528;
float _1273535;
float p_1273535;
int converge_1273538;
int pconverge_1273538;
float _1273543;
float p_1273543;
int converge_1273548;
int pconverge_1273548;
float _1273553;
float p_1273553;
int converge_1273556;
int pconverge_1273556;
float _1273563;
float p_1273563;
_1273491 = threadIdx_x();
p_1273491 = _1273491;
l1273489: ;
_1273491 = p_1273491;
_1273494 = blockDim_x();
p_1273494 = _1273494;
l1273492: ;
_1273494 = p_1273494;
_1273497 = blockIdx_x();
p_1273497 = _1273497;
l1273495: ;
_1273497 = p_1273497;
_1273500 = threadIdx_y();
p_1273500 = _1273500;
l1273498: ;
_1273500 = p_1273500;
_1273503 = blockDim_y();
p_1273503 = _1273503;
l1273501: ;
_1273503 = p_1273503;
_1273506 = blockIdx_y();
p_1273506 = _1273506;
l1273504: ;
_1273506 = p_1273506;
_1273509 = blockDim_y();
p_1273509 = _1273509;
l1273507: ;
_1273509 = p_1273509;
int _1273510;
_1273510 = _1273494 * _1273497;
int gid_x_1273511;
gid_x_1273511 = _1273491 + _1273510;
bool _1273512;
_1273512 = gid_x_1273511 < 0;
int _1273584;
_1273584 = 0 - gid_x_1273511;
int _1273585;
_1273585 = _1273584 - 1;
if (_1273512) goto l1273513; else goto l1273594;
l1273594: ;
pconverge_1273515 = gid_x_1273511;
goto l1273514;
l1273513: ;
pconverge_1273515 = _1273585;
goto l1273514;
l1273514: ;
converge_1273515 = pconverge_1273515;
int _1273516;
_1273516 = _1273503 * _1273506;
int gid_y_1273517;
gid_y_1273517 = _1273500 + _1273516;
int _1273518;
_1273518 = gid_y_1273517 * _996465_1273488;
int _1273519;
_1273519 = _1273518 + converge_1273515;
float* idx_1273520;
idx_1273520 = _996463_1273486 + _1273519;
_1273523 = __ldg(idx_1273520);
p_1273523 = _1273523;
l1273521: ;
_1273523 = p_1273523;
int _1273524;
_1273524 = -1 + gid_x_1273511;
bool _1273525;
_1273525 = _1273524 < 0;
if (_1273525) goto l1273526; else goto l1273593;
l1273593: ;
pconverge_1273528 = _1273524;
goto l1273527;
l1273526: ;
int _1273591;
_1273591 = 0 - _1273524;
int _1273592;
_1273592 = _1273591 - 1;
pconverge_1273528 = _1273592;
goto l1273527;
l1273527: ;
converge_1273528 = pconverge_1273528;
int _1273529;
_1273529 = 1 + gid_y_1273517;
int _1273530;
_1273530 = _1273529 * _996465_1273488;
int _1273531;
_1273531 = _1273530 + converge_1273528;
float* idx_1273532;
idx_1273532 = _996463_1273486 + _1273531;
_1273535 = __ldg(idx_1273532);
p_1273535 = _1273535;
l1273533: ;
_1273535 = p_1273535;
if (_1273512) goto l1273536; else goto l1273590;
l1273590: ;
pconverge_1273538 = gid_x_1273511;
goto l1273537;
l1273536: ;
pconverge_1273538 = _1273585;
goto l1273537;
l1273537: ;
converge_1273538 = pconverge_1273538;
int _1273539;
_1273539 = _1273530 + converge_1273538;
float* idx_1273540;
idx_1273540 = _996463_1273486 + _1273539;
_1273543 = __ldg(idx_1273540);
p_1273543 = _1273543;
l1273541: ;
_1273543 = p_1273543;
int _1273544;
_1273544 = 1 + gid_x_1273511;
bool _1273545;
_1273545 = _1273544 < 0;
if (_1273545) goto l1273546; else goto l1273589;
l1273589: ;
pconverge_1273548 = _1273544;
goto l1273547;
l1273546: ;
int _1273587;
_1273587 = 0 - _1273544;
int _1273588;
_1273588 = _1273587 - 1;
pconverge_1273548 = _1273588;
goto l1273547;
l1273547: ;
converge_1273548 = pconverge_1273548;
int _1273549;
_1273549 = _1273530 + converge_1273548;
float* idx_1273550;
idx_1273550 = _996463_1273486 + _1273549;
_1273553 = __ldg(idx_1273550);
p_1273553 = _1273553;
l1273551: ;
_1273553 = p_1273553;
if (_1273512) goto l1273554; else goto l1273586;
l1273586: ;
pconverge_1273556 = gid_x_1273511;
goto l1273555;
l1273554: ;
pconverge_1273556 = _1273585;
goto l1273555;
l1273555: ;
converge_1273556 = pconverge_1273556;
int _1273557;
_1273557 = 2 + gid_y_1273517;
int _1273558;
_1273558 = _1273557 * _996465_1273488;
int _1273559;
_1273559 = _1273558 + converge_1273556;
float* idx_1273560;
idx_1273560 = _996463_1273486 + _1273559;
_1273563 = __ldg(idx_1273560);
p_1273563 = _1273563;
l1273561: ;
_1273563 = p_1273563;
float _1273573;
_1273573 = 1.000000e+00f * _1273523;
int _1273564;
_1273564 = 4 * _996465_1273488;
float _1273581;
_1273581 = 1.000000e+00f * _1273563;
float _1273579;
_1273579 = 1.000000e+00f * _1273553;
float _1273575;
_1273575 = 1.000000e+00f * _1273535;
int _1273565;
_1273565 = 64 + _1273564;
int _1273566;
_1273566 = _1273565 - 1;
float _1273577;
_1273577 = -4.000000e+00f * _1273543;
float _1273574;
_1273574 = 0.000000e+00f + _1273573;
float _1273576;
_1273576 = _1273574 + _1273575;
int _1273567;
_1273567 = _1273566 / 64;
float _1273578;
_1273578 = _1273576 + _1273577;
int _1273568;
_1273568 = 64 * _1273567;
float _1273580;
_1273580 = _1273578 + _1273579;
int stride_1273569;
stride_1273569 = _1273568 / 4;
float _1273582;
_1273582 = _1273580 + _1273581;
int _1273570;
_1273570 = _1273529 * stride_1273569;
int _1273571;
_1273571 = _1273570 + gid_x_1273511;
float* idx_1273572;
idx_1273572 = _996464_1273487 + _1273571;
*idx_1273572 = _1273582;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1009614(struct_Img_220118 _1009617_1278072, struct_Img_220118 _1009618_1278073, float* _1009619_1278074, struct_Img_220118 _1009620_1278075, float* _1009621_1278076, float* _1009622_1278077) {
int _1278080;
int p_1278080;
int _1278083;
int p_1278083;
int _1278086;
int p_1278086;
int _1278089;
int p_1278089;
int _1278092;
int p_1278092;
int _1278095;
int p_1278095;
int _1278098;
int p_1278098;
struct_BoundaryMode_220129 bh_lower_1278105;
struct_BoundaryMode_220129 pbh_lower_1278105;
struct_BoundaryMode_220129 bh_lower_1278112;
struct_BoundaryMode_220129 pbh_lower_1278112;
float _1278129;
float p_1278129;
float _1278132;
float p_1278132;
struct_BoundaryMode_220129 bh_lower_1278136;
struct_BoundaryMode_220129 pbh_lower_1278136;
struct_BoundaryMode_220129 bh_lower_1278142;
struct_BoundaryMode_220129 pbh_lower_1278142;
float _1278158;
float p_1278158;
float _1278161;
float p_1278161;
struct_BoundaryMode_220129 bh_lower_1278167;
struct_BoundaryMode_220129 pbh_lower_1278167;
struct_BoundaryMode_220129 bh_lower_1278171;
struct_BoundaryMode_220129 pbh_lower_1278171;
float _1278187;
float p_1278187;
float _1278190;
float p_1278190;
struct_BoundaryMode_220129 bh_lower_1278196;
struct_BoundaryMode_220129 pbh_lower_1278196;
struct_BoundaryMode_220129 bh_lower_1278200;
struct_BoundaryMode_220129 pbh_lower_1278200;
float _1278216;
float p_1278216;
float _1278219;
float p_1278219;
struct_BoundaryMode_220129 bh_lower_1278223;
struct_BoundaryMode_220129 pbh_lower_1278223;
struct_BoundaryMode_220129 bh_lower_1278229;
struct_BoundaryMode_220129 pbh_lower_1278229;
float _1278245;
float p_1278245;
float _1278248;
float p_1278248;
_1278080 = threadIdx_x();
p_1278080 = _1278080;
l1278078: ;
_1278080 = p_1278080;
_1278083 = blockDim_x();
p_1278083 = _1278083;
l1278081: ;
_1278083 = p_1278083;
_1278086 = blockIdx_x();
p_1278086 = _1278086;
l1278084: ;
_1278086 = p_1278086;
_1278089 = threadIdx_y();
p_1278089 = _1278089;
l1278087: ;
_1278089 = p_1278089;
_1278092 = blockDim_y();
p_1278092 = _1278092;
l1278090: ;
_1278092 = p_1278092;
_1278095 = blockIdx_y();
p_1278095 = _1278095;
l1278093: ;
_1278095 = p_1278095;
_1278098 = blockDim_y();
p_1278098 = _1278098;
l1278096: ;
_1278098 = p_1278098;
int _1278099;
_1278099 = _1278083 * _1278086;
int gid_x_1278100;
gid_x_1278100 = _1278080 + _1278099;
bool _1278101;
_1278101 = gid_x_1278100 < 0;
union variant_220130 _1278285;
_1278285.qs32 = gid_x_1278100;
struct_BoundaryMode_220129 _1278286;
_1278286.e0 = 0;
_1278286.e1 = _1278285;
if (_1278101) goto l1278102; else goto l1278339;
l1278339: ;
pbh_lower_1278105 = _1278286;
goto l1278103;
l1278102: ;
union variant_220130 _1265919_172;
_1265919_172.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_174;
_1265920_174.e0 = 1;
_1265920_174.e1 = _1265919_172;
pbh_lower_1278105 = _1265920_174;
goto l1278103;
l1278103: ;
bh_lower_1278105 = pbh_lower_1278105;
int _1278106;
_1278106 = _1278092 * _1278095;
int gid_y_1278107;
gid_y_1278107 = _1278089 + _1278106;
union variant_220130 _1278297;
_1278297.qs32 = gid_y_1278107;
bool _1278108;
_1278108 = gid_y_1278107 < 0;
struct_BoundaryMode_220129 _1278298;
_1278298.e0 = 0;
_1278298.e1 = _1278297;
if (_1278108) goto l1278109; else goto l1278338;
l1278338: ;
pbh_lower_1278112 = _1278298;
goto l1278110;
l1278109: ;
union variant_220130 _1265919_182;
_1265919_182.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_184;
_1265920_184.e0 = 1;
_1265920_184.e1 = _1265919_182;
pbh_lower_1278112 = _1265920_184;
goto l1278110;
l1278110: ;
bh_lower_1278112 = pbh_lower_1278112;
union variant_220130 _1278119;
_1278119 = bh_lower_1278112.e1;
union variant_220130 _1278123;
_1278123 = bh_lower_1278105.e1;
int _1278121;
_1278121 = _1009617_1278072.e3;
unsigned int _1278113;
_1278113 = bh_lower_1278105.e0;
unsigned int _1278115;
_1278115 = bh_lower_1278112.e0;
bool _1278114;
_1278114 = _1278113 == 0;
bool _1278116;
_1278116 = _1278115 == 0;
bool _1278117;
_1278117 = _1278114 & _1278116;
if (_1278117) goto l1278118; else goto l1278329;
l1278329: ;
bool _1278330;
_1278330 = _1278113 == 1;
if (_1278330) goto l1278331; else goto l1278333;
l1278333: ;
bool _1278334;
_1278334 = _1278115 == 1;
if (_1278334) goto l1278335; else goto l1278337;
l1278337: ;
// bottom: float r4_1265918_197;
// bottom: p_1278132 = r4_1265918_197;
goto l1278130;
l1278335: ;
float c_1278336;
c_1278336 = _1278119.pf32;
p_1278132 = c_1278336;
goto l1278130;
l1278331: ;
float c_1278332;
c_1278332 = _1278123.pf32;
p_1278132 = c_1278332;
goto l1278130;
l1278118: ;
int y_1278120;
y_1278120 = _1278119.qs32;
int x_1278124;
x_1278124 = _1278123.qs32;
int _1278122;
_1278122 = y_1278120 * _1278121;
int _1278125;
_1278125 = _1278122 + x_1278124;
float* idx_1278126;
idx_1278126 = _1009621_1278076 + _1278125;
_1278129 = __ldg(idx_1278126);
p_1278129 = _1278129;
l1278127: ;
_1278129 = p_1278129;
p_1278132 = _1278129;
goto l1278130;
l1278130: ;
_1278132 = p_1278132;
int _1278254;
_1278254 = _1009618_1278073.e3;
int _1278255;
_1278255 = gid_y_1278107 * _1278254;
int _1278256;
_1278256 = _1278255 + gid_x_1278100;
float* idx_1278257;
idx_1278257 = _1009622_1278077 + _1278256;
float _1278258;
_1278258 = *idx_1278257;
if (_1278101) goto l1278133; else goto l1278328;
l1278328: ;
pbh_lower_1278136 = _1278286;
goto l1278134;
l1278133: ;
union variant_220130 _1265919_199;
_1265919_199.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_201;
_1265920_201.e0 = 1;
_1265920_201.e1 = _1265919_199;
pbh_lower_1278136 = _1265920_201;
goto l1278134;
l1278134: ;
bh_lower_1278136 = pbh_lower_1278136;
int _1278137;
_1278137 = -1 + gid_y_1278107;
bool _1278138;
_1278138 = _1278137 < 0;
if (_1278138) goto l1278139; else goto l1278324;
l1278324: ;
union variant_220130 _1278325;
_1278325.qs32 = _1278137;
struct_BoundaryMode_220129 _1278326;
_1278326.e0 = 0;
_1278326.e1 = _1278325;
pbh_lower_1278142 = _1278326;
goto l1278140;
l1278139: ;
union variant_220130 _1265919_210;
_1265919_210.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_212;
_1265920_212.e0 = 1;
_1265920_212.e1 = _1265919_210;
pbh_lower_1278142 = _1265920_212;
goto l1278140;
l1278140: ;
bh_lower_1278142 = pbh_lower_1278142;
unsigned int _1278145;
_1278145 = bh_lower_1278142.e0;
union variant_220130 _1278149;
_1278149 = bh_lower_1278142.e1;
union variant_220130 _1278152;
_1278152 = bh_lower_1278136.e1;
bool _1278146;
_1278146 = _1278145 == 0;
unsigned int _1278143;
_1278143 = bh_lower_1278136.e0;
bool _1278144;
_1278144 = _1278143 == 0;
bool _1278147;
_1278147 = _1278144 & _1278146;
if (_1278147) goto l1278148; else goto l1278315;
l1278315: ;
bool _1278316;
_1278316 = _1278143 == 1;
if (_1278316) goto l1278317; else goto l1278319;
l1278319: ;
bool _1278320;
_1278320 = _1278145 == 1;
if (_1278320) goto l1278321; else goto l1278323;
l1278323: ;
// bottom: float r4_1265918_224;
// bottom: p_1278161 = r4_1265918_224;
goto l1278159;
l1278321: ;
float c_1278322;
c_1278322 = _1278149.pf32;
p_1278161 = c_1278322;
goto l1278159;
l1278317: ;
float c_1278318;
c_1278318 = _1278152.pf32;
p_1278161 = c_1278318;
goto l1278159;
l1278148: ;
int x_1278153;
x_1278153 = _1278152.qs32;
int y_1278150;
y_1278150 = _1278149.qs32;
int _1278151;
_1278151 = y_1278150 * _1278121;
int _1278154;
_1278154 = _1278151 + x_1278153;
float* idx_1278155;
idx_1278155 = _1009621_1278076 + _1278154;
_1278158 = __ldg(idx_1278155);
p_1278158 = _1278158;
l1278156: ;
_1278158 = p_1278158;
p_1278161 = _1278158;
goto l1278159;
l1278159: ;
_1278161 = p_1278161;
int _1278162;
_1278162 = -1 + gid_x_1278100;
bool _1278163;
_1278163 = _1278162 < 0;
if (_1278163) goto l1278164; else goto l1278312;
l1278312: ;
union variant_220130 _1278313;
_1278313.qs32 = _1278162;
struct_BoundaryMode_220129 _1278314;
_1278314.e0 = 0;
_1278314.e1 = _1278313;
pbh_lower_1278167 = _1278314;
goto l1278165;
l1278164: ;
union variant_220130 _1265919_230;
_1265919_230.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_232;
_1265920_232.e0 = 1;
_1265920_232.e1 = _1265919_230;
pbh_lower_1278167 = _1265920_232;
goto l1278165;
l1278165: ;
bh_lower_1278167 = pbh_lower_1278167;
if (_1278108) goto l1278168; else goto l1278311;
l1278311: ;
pbh_lower_1278171 = _1278298;
goto l1278169;
l1278168: ;
union variant_220130 _1265919_236;
_1265919_236.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_238;
_1265920_238.e0 = 1;
_1265920_238.e1 = _1265919_236;
pbh_lower_1278171 = _1265920_238;
goto l1278169;
l1278169: ;
bh_lower_1278171 = pbh_lower_1278171;
union variant_220130 _1278181;
_1278181 = bh_lower_1278167.e1;
unsigned int _1278172;
_1278172 = bh_lower_1278167.e0;
unsigned int _1278174;
_1278174 = bh_lower_1278171.e0;
union variant_220130 _1278178;
_1278178 = bh_lower_1278171.e1;
bool _1278173;
_1278173 = _1278172 == 0;
bool _1278175;
_1278175 = _1278174 == 0;
bool _1278176;
_1278176 = _1278173 & _1278175;
if (_1278176) goto l1278177; else goto l1278302;
l1278302: ;
bool _1278303;
_1278303 = _1278172 == 1;
if (_1278303) goto l1278304; else goto l1278306;
l1278306: ;
bool _1278307;
_1278307 = _1278174 == 1;
if (_1278307) goto l1278308; else goto l1278310;
l1278310: ;
// bottom: float r4_1265918_250;
// bottom: p_1278190 = r4_1265918_250;
goto l1278188;
l1278308: ;
float c_1278309;
c_1278309 = _1278178.pf32;
p_1278190 = c_1278309;
goto l1278188;
l1278304: ;
float c_1278305;
c_1278305 = _1278181.pf32;
p_1278190 = c_1278305;
goto l1278188;
l1278177: ;
int x_1278182;
x_1278182 = _1278181.qs32;
int y_1278179;
y_1278179 = _1278178.qs32;
int _1278180;
_1278180 = y_1278179 * _1278121;
int _1278183;
_1278183 = _1278180 + x_1278182;
float* idx_1278184;
idx_1278184 = _1009621_1278076 + _1278183;
_1278187 = __ldg(idx_1278184);
p_1278187 = _1278187;
l1278185: ;
_1278187 = p_1278187;
p_1278190 = _1278187;
goto l1278188;
l1278188: ;
_1278190 = p_1278190;
int _1278191;
_1278191 = 1 + gid_x_1278100;
bool _1278192;
_1278192 = _1278191 < 0;
if (_1278192) goto l1278193; else goto l1278299;
l1278299: ;
union variant_220130 _1278300;
_1278300.qs32 = _1278191;
struct_BoundaryMode_220129 _1278301;
_1278301.e0 = 0;
_1278301.e1 = _1278300;
pbh_lower_1278196 = _1278301;
goto l1278194;
l1278193: ;
union variant_220130 _1265919_256;
_1265919_256.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_258;
_1265920_258.e0 = 1;
_1265920_258.e1 = _1265919_256;
pbh_lower_1278196 = _1265920_258;
goto l1278194;
l1278194: ;
bh_lower_1278196 = pbh_lower_1278196;
if (_1278108) goto l1278197; else goto l1278296;
l1278296: ;
pbh_lower_1278200 = _1278298;
goto l1278198;
l1278197: ;
union variant_220130 _1265919_262;
_1265919_262.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_264;
_1265920_264.e0 = 1;
_1265920_264.e1 = _1265919_262;
pbh_lower_1278200 = _1265920_264;
goto l1278198;
l1278198: ;
bh_lower_1278200 = pbh_lower_1278200;
union variant_220130 _1278207;
_1278207 = bh_lower_1278200.e1;
unsigned int _1278203;
_1278203 = bh_lower_1278200.e0;
union variant_220130 _1278210;
_1278210 = bh_lower_1278196.e1;
unsigned int _1278201;
_1278201 = bh_lower_1278196.e0;
bool _1278204;
_1278204 = _1278203 == 0;
bool _1278202;
_1278202 = _1278201 == 0;
bool _1278205;
_1278205 = _1278202 & _1278204;
if (_1278205) goto l1278206; else goto l1278287;
l1278287: ;
bool _1278288;
_1278288 = _1278201 == 1;
if (_1278288) goto l1278289; else goto l1278291;
l1278291: ;
bool _1278292;
_1278292 = _1278203 == 1;
if (_1278292) goto l1278293; else goto l1278295;
l1278295: ;
// bottom: float r4_1265918_276;
// bottom: p_1278219 = r4_1265918_276;
goto l1278217;
l1278293: ;
float c_1278294;
c_1278294 = _1278207.pf32;
p_1278219 = c_1278294;
goto l1278217;
l1278289: ;
float c_1278290;
c_1278290 = _1278210.pf32;
p_1278219 = c_1278290;
goto l1278217;
l1278206: ;
int y_1278208;
y_1278208 = _1278207.qs32;
int _1278209;
_1278209 = y_1278208 * _1278121;
int x_1278211;
x_1278211 = _1278210.qs32;
int _1278212;
_1278212 = _1278209 + x_1278211;
float* idx_1278213;
idx_1278213 = _1009621_1278076 + _1278212;
_1278216 = __ldg(idx_1278213);
p_1278216 = _1278216;
l1278214: ;
_1278216 = p_1278216;
p_1278219 = _1278216;
goto l1278217;
l1278217: ;
_1278219 = p_1278219;
if (_1278101) goto l1278220; else goto l1278284;
l1278284: ;
pbh_lower_1278223 = _1278286;
goto l1278221;
l1278220: ;
union variant_220130 _1265919_277;
_1265919_277.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_279;
_1265920_279.e0 = 1;
_1265920_279.e1 = _1265919_277;
pbh_lower_1278223 = _1265920_279;
goto l1278221;
l1278221: ;
bh_lower_1278223 = pbh_lower_1278223;
int _1278224;
_1278224 = 1 + gid_y_1278107;
bool _1278225;
_1278225 = _1278224 < 0;
if (_1278225) goto l1278226; else goto l1278281;
l1278281: ;
union variant_220130 _1278282;
_1278282.qs32 = _1278224;
struct_BoundaryMode_220129 _1278283;
_1278283.e0 = 0;
_1278283.e1 = _1278282;
pbh_lower_1278229 = _1278283;
goto l1278227;
l1278226: ;
union variant_220130 _1265919_288;
_1265919_288.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_290;
_1265920_290.e0 = 1;
_1265920_290.e1 = _1265919_288;
pbh_lower_1278229 = _1265920_290;
goto l1278227;
l1278227: ;
bh_lower_1278229 = pbh_lower_1278229;
unsigned int _1278232;
_1278232 = bh_lower_1278229.e0;
union variant_220130 _1278239;
_1278239 = bh_lower_1278223.e1;
union variant_220130 _1278236;
_1278236 = bh_lower_1278229.e1;
unsigned int _1278230;
_1278230 = bh_lower_1278223.e0;
bool _1278233;
_1278233 = _1278232 == 0;
bool _1278231;
_1278231 = _1278230 == 0;
bool _1278234;
_1278234 = _1278231 & _1278233;
if (_1278234) goto l1278235; else goto l1278272;
l1278272: ;
bool _1278273;
_1278273 = _1278230 == 1;
if (_1278273) goto l1278274; else goto l1278276;
l1278276: ;
bool _1278277;
_1278277 = _1278232 == 1;
if (_1278277) goto l1278278; else goto l1278280;
l1278280: ;
// bottom: float r4_1265918_302;
// bottom: p_1278248 = r4_1265918_302;
goto l1278246;
l1278278: ;
float c_1278279;
c_1278279 = _1278236.pf32;
p_1278248 = c_1278279;
goto l1278246;
l1278274: ;
float c_1278275;
c_1278275 = _1278239.pf32;
p_1278248 = c_1278275;
goto l1278246;
l1278235: ;
int y_1278237;
y_1278237 = _1278236.qs32;
int _1278238;
_1278238 = y_1278237 * _1278121;
int x_1278240;
x_1278240 = _1278239.qs32;
int _1278241;
_1278241 = _1278238 + x_1278240;
float* idx_1278242;
idx_1278242 = _1009621_1278076 + _1278241;
_1278245 = __ldg(idx_1278242);
p_1278245 = _1278245;
l1278243: ;
_1278245 = p_1278245;
p_1278248 = _1278245;
goto l1278246;
l1278246: ;
_1278248 = p_1278248;
int _1278249;
_1278249 = _1009620_1278075.e3;
float _1278266;
_1278266 = 2.500000e-01f * _1278219;
float _1278259;
_1278259 = _1278258;
float _1278268;
_1278268 = 2.500000e-01f * _1278248;
float _1278262;
_1278262 = 2.500000e-01f * _1278161;
float _1278253;
_1278253 = 2.000000e-01f * _1278132;
float _1278263;
_1278263 = 0.000000e+00f + _1278262;
float _1278264;
_1278264 = 2.500000e-01f * _1278190;
int _1278250;
_1278250 = gid_y_1278107 * _1278249;
float _1278260;
_1278260 = 2.000000e-01f * _1278259;
float _1278261;
_1278261 = _1278253 + _1278260;
float _1278265;
_1278265 = _1278263 + _1278264;
int _1278251;
_1278251 = _1278250 + gid_x_1278100;
float _1278267;
_1278267 = _1278265 + _1278266;
float* idx_1278252;
idx_1278252 = _1009619_1278074 + _1278251;
float _1278269;
_1278269 = _1278267 + _1278268;
float val_1278270;
val_1278270 = _1278261 + _1278269;
*idx_1278252 = val_1278270;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1019920(float* _1019923_1266146, struct_Img_220118 _1019924_1266147, float* _1019925_1266148, float* _1019926_1266149, struct_Img_220118 _1019927_1266150, struct_Img_220118 _1019928_1266151) {
int _1266154;
int p_1266154;
int _1266157;
int p_1266157;
int _1266160;
int p_1266160;
int _1266163;
int p_1266163;
int _1266166;
int p_1266166;
int _1266169;
int p_1266169;
int _1266172;
int p_1266172;
struct_BoundaryMode_220129 bh_lower_1266180;
struct_BoundaryMode_220129 pbh_lower_1266180;
float _1266195;
float p_1266195;
float _1266198;
float p_1266198;
struct_BoundaryMode_220129 bh_lower_1266202;
struct_BoundaryMode_220129 pbh_lower_1266202;
float _1266213;
float p_1266213;
float _1266216;
float p_1266216;
struct_BoundaryMode_220129 bh_lower_1266222;
struct_BoundaryMode_220129 pbh_lower_1266222;
float _1266232;
float p_1266232;
float _1266235;
float p_1266235;
struct_BoundaryMode_220129 bh_lower_1266241;
struct_BoundaryMode_220129 pbh_lower_1266241;
float _1266251;
float p_1266251;
float _1266254;
float p_1266254;
struct_BoundaryMode_220129 bh_lower_1266258;
struct_BoundaryMode_220129 pbh_lower_1266258;
float _1266270;
float p_1266270;
float _1266273;
float p_1266273;
_1266154 = threadIdx_x();
p_1266154 = _1266154;
l1266152: ;
_1266154 = p_1266154;
_1266157 = blockDim_x();
p_1266157 = _1266157;
l1266155: ;
_1266157 = p_1266157;
_1266160 = blockIdx_x();
p_1266160 = _1266160;
l1266158: ;
_1266160 = p_1266160;
_1266163 = threadIdx_y();
p_1266163 = _1266163;
l1266161: ;
_1266163 = p_1266163;
_1266166 = blockDim_y();
p_1266166 = _1266166;
l1266164: ;
_1266166 = p_1266166;
_1266169 = blockIdx_y();
p_1266169 = _1266169;
l1266167: ;
_1266169 = p_1266169;
_1266172 = blockDim_y();
p_1266172 = _1266172;
l1266170: ;
_1266172 = p_1266172;
int _1266173;
_1266173 = _1266157 * _1266160;
int gid_x_1266174;
gid_x_1266174 = _1266154 + _1266173;
bool _1266176;
_1266176 = gid_x_1266174 < 0;
union variant_220130 _1266303;
_1266303.qs32 = gid_x_1266174;
struct_BoundaryMode_220129 _1266304;
_1266304.e0 = 0;
_1266304.e1 = _1266303;
if (_1266176) goto l1266177; else goto l1266333;
l1266333: ;
pbh_lower_1266180 = _1266304;
goto l1266178;
l1266177: ;
union variant_220130 _1265919_315;
_1265919_315.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_317;
_1265920_317.e0 = 1;
_1265920_317.e1 = _1265919_315;
pbh_lower_1266180 = _1265920_317;
goto l1266178;
l1266178: ;
bh_lower_1266180 = pbh_lower_1266180;
int _1266187;
_1266187 = _1019927_1266150.e3;
union variant_220130 _1266189;
_1266189 = bh_lower_1266180.e1;
int _1266184;
_1266184 = _1266166 * _1266169;
unsigned int _1266181;
_1266181 = bh_lower_1266180.e0;
int gid_y_1266185;
gid_y_1266185 = _1266163 + _1266184;
bool _1266182;
_1266182 = _1266181 == 0;
int _1266186;
_1266186 = 1 + gid_y_1266185;
int _1266188;
_1266188 = _1266186 * _1266187;
if (_1266182) goto l1266183; else goto l1266328;
l1266328: ;
bool _1266329;
_1266329 = _1266181 == 1;
if (_1266329) goto l1266330; else goto l1266332;
l1266332: ;
// bottom: float r4_1265918_327;
// bottom: p_1266198 = r4_1265918_327;
goto l1266196;
l1266330: ;
float c_1266331;
c_1266331 = _1266189.pf32;
p_1266198 = c_1266331;
goto l1266196;
l1266183: ;
int x_1266190;
x_1266190 = _1266189.qs32;
int _1266191;
_1266191 = _1266188 + x_1266190;
float* idx_1266192;
idx_1266192 = _1019926_1266149 + _1266191;
_1266195 = __ldg(idx_1266192);
p_1266195 = _1266195;
l1266193: ;
_1266195 = p_1266195;
p_1266198 = _1266195;
goto l1266196;
l1266196: ;
_1266198 = p_1266198;
int _1266279;
_1266279 = _1019928_1266151.e3;
int _1266280;
_1266280 = _1266186 * _1266279;
int _1266281;
_1266281 = _1266280 + gid_x_1266174;
float* idx_1266282;
idx_1266282 = _1019923_1266146 + _1266281;
float _1266283;
_1266283 = *idx_1266282;
if (_1266176) goto l1266199; else goto l1266327;
l1266327: ;
pbh_lower_1266202 = _1266304;
goto l1266200;
l1266199: ;
union variant_220130 _1265919_329;
_1265919_329.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_331;
_1265920_331.e0 = 1;
_1265920_331.e1 = _1265919_329;
pbh_lower_1266202 = _1265920_331;
goto l1266200;
l1266200: ;
bh_lower_1266202 = pbh_lower_1266202;
unsigned int _1266203;
_1266203 = bh_lower_1266202.e0;
union variant_220130 _1266207;
_1266207 = bh_lower_1266202.e1;
bool _1266204;
_1266204 = _1266203 == 0;
if (_1266204) goto l1266205; else goto l1266321;
l1266321: ;
bool _1266322;
_1266322 = _1266203 == 1;
if (_1266322) goto l1266323; else goto l1266325;
l1266325: ;
// bottom: float r4_1265918_339;
// bottom: p_1266216 = r4_1265918_339;
goto l1266214;
l1266323: ;
float c_1266324;
c_1266324 = _1266207.pf32;
p_1266216 = c_1266324;
goto l1266214;
l1266205: ;
int _1266206;
_1266206 = gid_y_1266185 * _1266187;
int x_1266208;
x_1266208 = _1266207.qs32;
int _1266209;
_1266209 = _1266206 + x_1266208;
float* idx_1266210;
idx_1266210 = _1019926_1266149 + _1266209;
_1266213 = __ldg(idx_1266210);
p_1266213 = _1266213;
l1266211: ;
_1266213 = p_1266213;
p_1266216 = _1266213;
goto l1266214;
l1266214: ;
_1266216 = p_1266216;
int _1266217;
_1266217 = -1 + gid_x_1266174;
bool _1266218;
_1266218 = _1266217 < 0;
if (_1266218) goto l1266219; else goto l1266318;
l1266318: ;
union variant_220130 _1266319;
_1266319.qs32 = _1266217;
struct_BoundaryMode_220129 _1266320;
_1266320.e0 = 0;
_1266320.e1 = _1266319;
pbh_lower_1266222 = _1266320;
goto l1266220;
l1266219: ;
union variant_220130 _1265919_345;
_1265919_345.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_347;
_1265920_347.e0 = 1;
_1265920_347.e1 = _1265919_345;
pbh_lower_1266222 = _1265920_347;
goto l1266220;
l1266220: ;
bh_lower_1266222 = pbh_lower_1266222;
unsigned int _1266223;
_1266223 = bh_lower_1266222.e0;
union variant_220130 _1266226;
_1266226 = bh_lower_1266222.e1;
bool _1266224;
_1266224 = _1266223 == 0;
if (_1266224) goto l1266225; else goto l1266313;
l1266313: ;
bool _1266314;
_1266314 = _1266223 == 1;
if (_1266314) goto l1266315; else goto l1266317;
l1266317: ;
// bottom: float r4_1265918_355;
// bottom: p_1266235 = r4_1265918_355;
goto l1266233;
l1266315: ;
float c_1266316;
c_1266316 = _1266226.pf32;
p_1266235 = c_1266316;
goto l1266233;
l1266225: ;
int x_1266227;
x_1266227 = _1266226.qs32;
int _1266228;
_1266228 = _1266188 + x_1266227;
float* idx_1266229;
idx_1266229 = _1019926_1266149 + _1266228;
_1266232 = __ldg(idx_1266229);
p_1266232 = _1266232;
l1266230: ;
_1266232 = p_1266232;
p_1266235 = _1266232;
goto l1266233;
l1266233: ;
_1266235 = p_1266235;
int _1266236;
_1266236 = 1 + gid_x_1266174;
bool _1266237;
_1266237 = _1266236 < 0;
if (_1266237) goto l1266238; else goto l1266310;
l1266310: ;
union variant_220130 _1266311;
_1266311.qs32 = _1266236;
struct_BoundaryMode_220129 _1266312;
_1266312.e0 = 0;
_1266312.e1 = _1266311;
pbh_lower_1266241 = _1266312;
goto l1266239;
l1266238: ;
union variant_220130 _1265919_361;
_1265919_361.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_363;
_1265920_363.e0 = 1;
_1265920_363.e1 = _1265919_361;
pbh_lower_1266241 = _1265920_363;
goto l1266239;
l1266239: ;
bh_lower_1266241 = pbh_lower_1266241;
union variant_220130 _1266245;
_1266245 = bh_lower_1266241.e1;
unsigned int _1266242;
_1266242 = bh_lower_1266241.e0;
bool _1266243;
_1266243 = _1266242 == 0;
if (_1266243) goto l1266244; else goto l1266305;
l1266305: ;
bool _1266306;
_1266306 = _1266242 == 1;
if (_1266306) goto l1266307; else goto l1266309;
l1266309: ;
// bottom: float r4_1265918_371;
// bottom: p_1266254 = r4_1265918_371;
goto l1266252;
l1266307: ;
float c_1266308;
c_1266308 = _1266245.pf32;
p_1266254 = c_1266308;
goto l1266252;
l1266244: ;
int x_1266246;
x_1266246 = _1266245.qs32;
int _1266247;
_1266247 = _1266188 + x_1266246;
float* idx_1266248;
idx_1266248 = _1019926_1266149 + _1266247;
_1266251 = __ldg(idx_1266248);
p_1266251 = _1266251;
l1266249: ;
_1266251 = p_1266251;
p_1266254 = _1266251;
goto l1266252;
l1266252: ;
_1266254 = p_1266254;
if (_1266176) goto l1266255; else goto l1266302;
l1266302: ;
pbh_lower_1266258 = _1266304;
goto l1266256;
l1266255: ;
union variant_220130 _1265919_372;
_1265919_372.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_374;
_1265920_374.e0 = 1;
_1265920_374.e1 = _1265919_372;
pbh_lower_1266258 = _1265920_374;
goto l1266256;
l1266256: ;
bh_lower_1266258 = pbh_lower_1266258;
union variant_220130 _1266264;
_1266264 = bh_lower_1266258.e1;
unsigned int _1266259;
_1266259 = bh_lower_1266258.e0;
bool _1266260;
_1266260 = _1266259 == 0;
if (_1266260) goto l1266261; else goto l1266297;
l1266297: ;
bool _1266298;
_1266298 = _1266259 == 1;
if (_1266298) goto l1266299; else goto l1266301;
l1266301: ;
// bottom: float r4_1265918_382;
// bottom: p_1266273 = r4_1265918_382;
goto l1266271;
l1266299: ;
float c_1266300;
c_1266300 = _1266264.pf32;
p_1266273 = c_1266300;
goto l1266271;
l1266261: ;
int x_1266265;
x_1266265 = _1266264.qs32;
int _1266262;
_1266262 = 2 + gid_y_1266185;
int _1266263;
_1266263 = _1266262 * _1266187;
int _1266266;
_1266266 = _1266263 + x_1266265;
float* idx_1266267;
idx_1266267 = _1019926_1266149 + _1266266;
_1266270 = __ldg(idx_1266267);
p_1266270 = _1266270;
l1266268: ;
_1266270 = p_1266270;
p_1266273 = _1266270;
goto l1266271;
l1266271: ;
_1266273 = p_1266273;
float _1266289;
_1266289 = 2.500000e-01f * _1266235;
float _1266284;
_1266284 = _1266283;
int _1266274;
_1266274 = _1019924_1266147.e3;
float _1266287;
_1266287 = 2.500000e-01f * _1266216;
float _1266278;
_1266278 = 2.000000e-01f * _1266198;
float _1266291;
_1266291 = 2.500000e-01f * _1266254;
float _1266293;
_1266293 = 2.500000e-01f * _1266273;
float _1266285;
_1266285 = 2.000000e-01f * _1266284;
int _1266275;
_1266275 = _1266186 * _1266274;
float _1266288;
_1266288 = 0.000000e+00f + _1266287;
float _1266286;
_1266286 = _1266278 + _1266285;
int _1266276;
_1266276 = _1266275 + gid_x_1266174;
float _1266290;
_1266290 = _1266288 + _1266289;
float* idx_1266277;
idx_1266277 = _1019925_1266148 + _1266276;
float _1266292;
_1266292 = _1266290 + _1266291;
float _1266294;
_1266294 = _1266292 + _1266293;
float val_1266295;
val_1266295 = _1266286 + _1266294;
*idx_1266277 = val_1266295;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_999197(float* _999200_1271748, float* _999201_1271749, int _999202_1271750, int _999203_1271751) {
int _1271754;
int p_1271754;
int _1271757;
int p_1271757;
int _1271760;
int p_1271760;
int _1271763;
int p_1271763;
int _1271766;
int p_1271766;
int _1271769;
int p_1271769;
int _1271772;
int p_1271772;
int converge_1271780;
int pconverge_1271780;
int converge_1271789;
int pconverge_1271789;
float _1271795;
float p_1271795;
int converge_1271800;
int pconverge_1271800;
int converge_1271804;
int pconverge_1271804;
float _1271810;
float p_1271810;
int converge_1271813;
int pconverge_1271813;
int converge_1271816;
int pconverge_1271816;
float _1271822;
float p_1271822;
int converge_1271827;
int pconverge_1271827;
int converge_1271830;
int pconverge_1271830;
float _1271836;
float p_1271836;
int converge_1271839;
int pconverge_1271839;
int converge_1271844;
int pconverge_1271844;
float _1271850;
float p_1271850;
_1271754 = threadIdx_x();
p_1271754 = _1271754;
l1271752: ;
_1271754 = p_1271754;
_1271757 = blockDim_x();
p_1271757 = _1271757;
l1271755: ;
_1271757 = p_1271757;
_1271760 = blockIdx_x();
p_1271760 = _1271760;
l1271758: ;
_1271760 = p_1271760;
_1271763 = threadIdx_y();
p_1271763 = _1271763;
l1271761: ;
_1271763 = p_1271763;
_1271766 = blockDim_y();
p_1271766 = _1271766;
l1271764: ;
_1271766 = p_1271766;
_1271769 = blockIdx_y();
p_1271769 = _1271769;
l1271767: ;
_1271769 = p_1271769;
_1271772 = blockDim_y();
p_1271772 = _1271772;
l1271770: ;
_1271772 = p_1271772;
int _1271773;
_1271773 = _999203_1271751 - 128;
int _1271775;
_1271775 = _1271757 * _1271760;
int _1271774;
_1271774 = _1271773 + _1271754;
int gid_x_1271776;
gid_x_1271776 = _1271774 + _1271775;
int _1271823;
_1271823 = 1 + gid_x_1271776;
bool _1271777;
_1271777 = _999203_1271751 <= gid_x_1271776;
int _1271875;
_1271875 = _1271823 - _999203_1271751;
int _1271876;
_1271876 = _999203_1271751 - _1271875;
if (_1271777) goto l1271778; else goto l1271894;
l1271894: ;
pconverge_1271780 = gid_x_1271776;
goto l1271779;
l1271778: ;
pconverge_1271780 = _1271876;
goto l1271779;
l1271779: ;
converge_1271780 = pconverge_1271780;
int _1271783;
_1271783 = _1271766 * _1271769;
int _1271781;
_1271781 = _999202_1271750 - 1;
int _1271782;
_1271782 = _1271781 + _1271763;
int gid_y_1271784;
gid_y_1271784 = _1271782 + _1271783;
int _1271785;
_1271785 = -1 + gid_y_1271784;
bool _1271786;
_1271786 = _999202_1271750 <= _1271785;
if (_1271786) goto l1271787; else goto l1271893;
l1271893: ;
pconverge_1271789 = _1271785;
goto l1271788;
l1271787: ;
int _1271891;
_1271891 = gid_y_1271784 - _999202_1271750;
int _1271892;
_1271892 = _999202_1271750 - _1271891;
pconverge_1271789 = _1271892;
goto l1271788;
l1271788: ;
converge_1271789 = pconverge_1271789;
int _1271790;
_1271790 = converge_1271789 * _999203_1271751;
int _1271791;
_1271791 = _1271790 + converge_1271780;
float* idx_1271792;
idx_1271792 = _999200_1271748 + _1271791;
_1271795 = __ldg(idx_1271792);
p_1271795 = _1271795;
l1271793: ;
_1271795 = p_1271795;
int _1271796;
_1271796 = -1 + gid_x_1271776;
bool _1271797;
_1271797 = _999203_1271751 <= _1271796;
if (_1271797) goto l1271798; else goto l1271890;
l1271890: ;
pconverge_1271800 = _1271796;
goto l1271799;
l1271798: ;
int _1271888;
_1271888 = gid_x_1271776 - _999203_1271751;
int _1271889;
_1271889 = _999203_1271751 - _1271888;
pconverge_1271800 = _1271889;
goto l1271799;
l1271799: ;
converge_1271800 = pconverge_1271800;
int _1271840;
_1271840 = 1 + gid_y_1271784;
int _1271878;
_1271878 = _1271840 - _999202_1271750;
int _1271879;
_1271879 = _999202_1271750 - _1271878;
bool _1271801;
_1271801 = _999202_1271750 <= gid_y_1271784;
if (_1271801) goto l1271802; else goto l1271887;
l1271887: ;
pconverge_1271804 = gid_y_1271784;
goto l1271803;
l1271802: ;
pconverge_1271804 = _1271879;
goto l1271803;
l1271803: ;
converge_1271804 = pconverge_1271804;
int _1271805;
_1271805 = converge_1271804 * _999203_1271751;
int _1271806;
_1271806 = _1271805 + converge_1271800;
float* idx_1271807;
idx_1271807 = _999200_1271748 + _1271806;
_1271810 = __ldg(idx_1271807);
p_1271810 = _1271810;
l1271808: ;
_1271810 = p_1271810;
if (_1271777) goto l1271811; else goto l1271886;
l1271886: ;
pconverge_1271813 = gid_x_1271776;
goto l1271812;
l1271811: ;
pconverge_1271813 = _1271876;
goto l1271812;
l1271812: ;
converge_1271813 = pconverge_1271813;
if (_1271801) goto l1271814; else goto l1271885;
l1271885: ;
pconverge_1271816 = gid_y_1271784;
goto l1271815;
l1271814: ;
pconverge_1271816 = _1271879;
goto l1271815;
l1271815: ;
converge_1271816 = pconverge_1271816;
int _1271817;
_1271817 = converge_1271816 * _999203_1271751;
int _1271818;
_1271818 = _1271817 + converge_1271813;
float* idx_1271819;
idx_1271819 = _999200_1271748 + _1271818;
_1271822 = __ldg(idx_1271819);
p_1271822 = _1271822;
l1271820: ;
_1271822 = p_1271822;
bool _1271824;
_1271824 = _999203_1271751 <= _1271823;
if (_1271824) goto l1271825; else goto l1271884;
l1271884: ;
pconverge_1271827 = _1271823;
goto l1271826;
l1271825: ;
int _1271881;
_1271881 = 2 + gid_x_1271776;
int _1271882;
_1271882 = _1271881 - _999203_1271751;
int _1271883;
_1271883 = _999203_1271751 - _1271882;
pconverge_1271827 = _1271883;
goto l1271826;
l1271826: ;
converge_1271827 = pconverge_1271827;
if (_1271801) goto l1271828; else goto l1271880;
l1271880: ;
pconverge_1271830 = gid_y_1271784;
goto l1271829;
l1271828: ;
pconverge_1271830 = _1271879;
goto l1271829;
l1271829: ;
converge_1271830 = pconverge_1271830;
int _1271831;
_1271831 = converge_1271830 * _999203_1271751;
int _1271832;
_1271832 = _1271831 + converge_1271827;
float* idx_1271833;
idx_1271833 = _999200_1271748 + _1271832;
_1271836 = __ldg(idx_1271833);
p_1271836 = _1271836;
l1271834: ;
_1271836 = p_1271836;
if (_1271777) goto l1271837; else goto l1271877;
l1271877: ;
pconverge_1271839 = gid_x_1271776;
goto l1271838;
l1271837: ;
pconverge_1271839 = _1271876;
goto l1271838;
l1271838: ;
converge_1271839 = pconverge_1271839;
bool _1271841;
_1271841 = _999202_1271750 <= _1271840;
if (_1271841) goto l1271842; else goto l1271874;
l1271874: ;
pconverge_1271844 = _1271840;
goto l1271843;
l1271842: ;
int _1271871;
_1271871 = 2 + gid_y_1271784;
int _1271872;
_1271872 = _1271871 - _999202_1271750;
int _1271873;
_1271873 = _999202_1271750 - _1271872;
pconverge_1271844 = _1271873;
goto l1271843;
l1271843: ;
converge_1271844 = pconverge_1271844;
int _1271845;
_1271845 = converge_1271844 * _999203_1271751;
int _1271846;
_1271846 = _1271845 + converge_1271839;
float* idx_1271847;
idx_1271847 = _999200_1271748 + _1271846;
_1271850 = __ldg(idx_1271847);
p_1271850 = _1271850;
l1271848: ;
_1271850 = p_1271850;
float _1271866;
_1271866 = 1.000000e+00f * _1271836;
int _1271851;
_1271851 = 4 * _999203_1271751;
float _1271868;
_1271868 = 1.000000e+00f * _1271850;
float _1271860;
_1271860 = 1.000000e+00f * _1271795;
float _1271864;
_1271864 = -4.000000e+00f * _1271822;
float _1271862;
_1271862 = 1.000000e+00f * _1271810;
float _1271861;
_1271861 = 0.000000e+00f + _1271860;
int _1271852;
_1271852 = 64 + _1271851;
float _1271863;
_1271863 = _1271861 + _1271862;
int _1271853;
_1271853 = _1271852 - 1;
float _1271865;
_1271865 = _1271863 + _1271864;
int _1271854;
_1271854 = _1271853 / 64;
float _1271867;
_1271867 = _1271865 + _1271866;
int _1271855;
_1271855 = 64 * _1271854;
float _1271869;
_1271869 = _1271867 + _1271868;
int stride_1271856;
stride_1271856 = _1271855 / 4;
int _1271857;
_1271857 = gid_y_1271784 * stride_1271856;
int _1271858;
_1271858 = _1271857 + gid_x_1271776;
float* idx_1271859;
idx_1271859 = _999201_1271749 + _1271858;
*idx_1271859 = _1271869;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1016068(struct_Img_220118 _1016071_1266052, float* _1016072_1266053, struct_Img_220118 _1016073_1266054, float* _1016074_1266055, struct_Img_220118 _1016075_1266056, float* _1016076_1266057) {
int _1266060;
int p_1266060;
int _1266063;
int p_1266063;
int _1266066;
int p_1266066;
int _1266069;
int p_1266069;
int _1266072;
int p_1266072;
int _1266075;
int p_1266075;
int _1266078;
int p_1266078;
float _1266091;
float p_1266091;
float _1266105;
float p_1266105;
float _1266110;
float p_1266110;
float _1266115;
float p_1266115;
float _1266123;
float p_1266123;
_1266060 = threadIdx_x();
p_1266060 = _1266060;
l1266058: ;
_1266060 = p_1266060;
_1266063 = blockDim_x();
p_1266063 = _1266063;
l1266061: ;
_1266063 = p_1266063;
_1266066 = blockIdx_x();
p_1266066 = _1266066;
l1266064: ;
_1266066 = p_1266066;
_1266069 = threadIdx_y();
p_1266069 = _1266069;
l1266067: ;
_1266069 = p_1266069;
_1266072 = blockDim_y();
p_1266072 = _1266072;
l1266070: ;
_1266072 = p_1266072;
_1266075 = blockIdx_y();
p_1266075 = _1266075;
l1266073: ;
_1266075 = p_1266075;
_1266078 = blockDim_y();
p_1266078 = _1266078;
l1266076: ;
_1266078 = p_1266078;
int _1266082;
_1266082 = _1016075_1266056.e3;
int _1266079;
_1266079 = _1266072 * _1266075;
int gid_y_1266080;
gid_y_1266080 = _1266069 + _1266079;
int _1266081;
_1266081 = 1 + gid_y_1266080;
int _1266084;
_1266084 = _1266063 * _1266066;
int _1266083;
_1266083 = _1266081 * _1266082;
int gid_x_1266085;
gid_x_1266085 = _1266060 + _1266084;
int _1266086;
_1266086 = _1266083 + gid_x_1266085;
int _1266087;
_1266087 = 128 + _1266086;
float* idx_1266088;
idx_1266088 = _1016074_1266055 + _1266087;
_1266091 = __ldg(idx_1266088);
p_1266091 = _1266091;
l1266089: ;
_1266091 = p_1266091;
int _1266099;
_1266099 = gid_y_1266080 * _1266082;
int _1266092;
_1266092 = _1016071_1266052.e3;
int _1266100;
_1266100 = _1266099 + gid_x_1266085;
int _1266093;
_1266093 = _1266081 * _1266092;
int _1266101;
_1266101 = 128 + _1266100;
int _1266094;
_1266094 = _1266093 + gid_x_1266085;
float* idx_1266102;
idx_1266102 = _1016074_1266055 + _1266101;
int _1266095;
_1266095 = 128 + _1266094;
float* idx_1266096;
idx_1266096 = _1016076_1266057 + _1266095;
float _1266097;
_1266097 = *idx_1266096;
_1266105 = __ldg(idx_1266102);
p_1266105 = _1266105;
l1266103: ;
_1266105 = p_1266105;
int _1266106;
_1266106 = 127 + _1266086;
float* idx_1266107;
idx_1266107 = _1016074_1266055 + _1266106;
_1266110 = __ldg(idx_1266107);
p_1266110 = _1266110;
l1266108: ;
_1266110 = p_1266110;
int _1266111;
_1266111 = 129 + _1266086;
float* idx_1266112;
idx_1266112 = _1016074_1266055 + _1266111;
_1266115 = __ldg(idx_1266112);
p_1266115 = _1266115;
l1266113: ;
_1266115 = p_1266115;
int _1266116;
_1266116 = 2 + gid_y_1266080;
int _1266117;
_1266117 = _1266116 * _1266082;
int _1266118;
_1266118 = _1266117 + gid_x_1266085;
int _1266119;
_1266119 = 128 + _1266118;
float* idx_1266120;
idx_1266120 = _1016074_1266055 + _1266119;
_1266123 = __ldg(idx_1266120);
p_1266123 = _1266123;
l1266121: ;
_1266123 = p_1266123;
float _1266139;
_1266139 = 2.500000e-01f * _1266123;
float _1266137;
_1266137 = 2.500000e-01f * _1266115;
int _1266124;
_1266124 = _1016073_1266054.e3;
int _1266125;
_1266125 = _1266081 * _1266124;
float _1266135;
_1266135 = 2.500000e-01f * _1266110;
float _1266133;
_1266133 = 2.500000e-01f * _1266105;
float _1266129;
_1266129 = 2.000000e-01f * _1266091;
float _1266130;
_1266130 = _1266097;
float _1266134;
_1266134 = 0.000000e+00f + _1266133;
float _1266136;
_1266136 = _1266134 + _1266135;
float _1266138;
_1266138 = _1266136 + _1266137;
int _1266126;
_1266126 = _1266125 + gid_x_1266085;
float _1266131;
_1266131 = 2.000000e-01f * _1266130;
float _1266140;
_1266140 = _1266138 + _1266139;
int _1266127;
_1266127 = 128 + _1266126;
float _1266132;
_1266132 = _1266129 + _1266131;
float val_1266141;
val_1266141 = _1266132 + _1266140;
float* idx_1266128;
idx_1266128 = _1016072_1266053 + _1266127;
*idx_1266128 = val_1266141;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1031454(struct_Img_220118 _1031457_1281823, float* _1031458_1281824, float* _1031459_1281825, struct_Img_220118 _1031460_1281826, struct_Img_220118 _1031461_1281827, float* _1031462_1281828) {
int _1281831;
int p_1281831;
int _1281834;
int p_1281834;
int _1281837;
int p_1281837;
int _1281840;
int p_1281840;
int _1281843;
int p_1281843;
int _1281846;
int p_1281846;
int _1281849;
int p_1281849;
struct_BoundaryMode_220129 bh_upper_1281860;
struct_BoundaryMode_220129 pbh_upper_1281860;
struct_BoundaryMode_220129 bh_lower_1281867;
struct_BoundaryMode_220129 pbh_lower_1281867;
float _1281884;
float p_1281884;
float _1281887;
float p_1281887;
struct_BoundaryMode_220129 bh_upper_1281891;
struct_BoundaryMode_220129 pbh_upper_1281891;
struct_BoundaryMode_220129 bh_lower_1281897;
struct_BoundaryMode_220129 pbh_lower_1281897;
float _1281913;
float p_1281913;
float _1281916;
float p_1281916;
struct_BoundaryMode_220129 bh_upper_1281922;
struct_BoundaryMode_220129 pbh_upper_1281922;
struct_BoundaryMode_220129 bh_lower_1281926;
struct_BoundaryMode_220129 pbh_lower_1281926;
float _1281942;
float p_1281942;
float _1281945;
float p_1281945;
struct_BoundaryMode_220129 bh_upper_1281951;
struct_BoundaryMode_220129 pbh_upper_1281951;
struct_BoundaryMode_220129 bh_lower_1281955;
struct_BoundaryMode_220129 pbh_lower_1281955;
float _1281971;
float p_1281971;
float _1281974;
float p_1281974;
struct_BoundaryMode_220129 bh_upper_1281978;
struct_BoundaryMode_220129 pbh_upper_1281978;
struct_BoundaryMode_220129 bh_lower_1281984;
struct_BoundaryMode_220129 pbh_lower_1281984;
float _1282000;
float p_1282000;
float _1282003;
float p_1282003;
_1281831 = threadIdx_x();
p_1281831 = _1281831;
l1281829: ;
_1281831 = p_1281831;
_1281834 = blockDim_x();
p_1281834 = _1281834;
l1281832: ;
_1281834 = p_1281834;
_1281837 = blockIdx_x();
p_1281837 = _1281837;
l1281835: ;
_1281837 = p_1281837;
_1281840 = threadIdx_y();
p_1281840 = _1281840;
l1281838: ;
_1281840 = p_1281840;
_1281843 = blockDim_y();
p_1281843 = _1281843;
l1281841: ;
_1281843 = p_1281843;
_1281846 = blockIdx_y();
p_1281846 = _1281846;
l1281844: ;
_1281846 = p_1281846;
_1281849 = blockDim_y();
p_1281849 = _1281849;
l1281847: ;
_1281849 = p_1281849;
int _1281850;
_1281850 = _1031460_1281826.e1;
int _1281854;
_1281854 = _1281834 * _1281837;
int _1281851;
_1281851 = _1031461_1281827.e1;
int _1281852;
_1281852 = _1281851 - 128;
int _1281853;
_1281853 = _1281852 + _1281831;
int gid_x_1281855;
gid_x_1281855 = _1281853 + _1281854;
bool _1281856;
_1281856 = _1281850 <= gid_x_1281855;
union variant_220130 _1282040;
_1282040.qs32 = gid_x_1281855;
struct_BoundaryMode_220129 _1282041;
_1282041.e0 = 0;
_1282041.e1 = _1282040;
if (_1281856) goto l1281857; else goto l1282094;
l1282094: ;
pbh_upper_1281860 = _1282041;
goto l1281858;
l1281857: ;
union variant_220130 _1265919_437;
_1265919_437.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_439;
_1265920_439.e0 = 1;
_1265920_439.e1 = _1265919_437;
pbh_upper_1281860 = _1265920_439;
goto l1281858;
l1281858: ;
bh_upper_1281860 = pbh_upper_1281860;
int _1281861;
_1281861 = _1281843 * _1281846;
int gid_y_1281862;
gid_y_1281862 = _1281840 + _1281861;
union variant_220130 _1282052;
_1282052.qs32 = gid_y_1281862;
bool _1281863;
_1281863 = gid_y_1281862 < 0;
struct_BoundaryMode_220129 _1282053;
_1282053.e0 = 0;
_1282053.e1 = _1282052;
if (_1281863) goto l1281864; else goto l1282093;
l1282093: ;
pbh_lower_1281867 = _1282053;
goto l1281865;
l1281864: ;
union variant_220130 _1265919_447;
_1265919_447.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_449;
_1265920_449.e0 = 1;
_1265920_449.e1 = _1265919_447;
pbh_lower_1281867 = _1265920_449;
goto l1281865;
l1281865: ;
bh_lower_1281867 = pbh_lower_1281867;
union variant_220130 _1281874;
_1281874 = bh_lower_1281867.e1;
int _1281876;
_1281876 = _1031460_1281826.e3;
unsigned int _1281868;
_1281868 = bh_upper_1281860.e0;
union variant_220130 _1281878;
_1281878 = bh_upper_1281860.e1;
unsigned int _1281870;
_1281870 = bh_lower_1281867.e0;
bool _1281871;
_1281871 = _1281870 == 0;
bool _1281869;
_1281869 = _1281868 == 0;
bool _1281872;
_1281872 = _1281869 & _1281871;
if (_1281872) goto l1281873; else goto l1282084;
l1282084: ;
bool _1282085;
_1282085 = _1281868 == 1;
if (_1282085) goto l1282086; else goto l1282088;
l1282088: ;
bool _1282089;
_1282089 = _1281870 == 1;
if (_1282089) goto l1282090; else goto l1282092;
l1282092: ;
// bottom: float r4_1265918_462;
// bottom: p_1281887 = r4_1265918_462;
goto l1281885;
l1282090: ;
float c_1282091;
c_1282091 = _1281874.pf32;
p_1281887 = c_1282091;
goto l1281885;
l1282086: ;
float c_1282087;
c_1282087 = _1281878.pf32;
p_1281887 = c_1282087;
goto l1281885;
l1281873: ;
int y_1281875;
y_1281875 = _1281874.qs32;
int x_1281879;
x_1281879 = _1281878.qs32;
int _1281877;
_1281877 = y_1281875 * _1281876;
int _1281880;
_1281880 = _1281877 + x_1281879;
float* idx_1281881;
idx_1281881 = _1031459_1281825 + _1281880;
_1281884 = __ldg(idx_1281881);
p_1281884 = _1281884;
l1281882: ;
_1281884 = p_1281884;
p_1281887 = _1281884;
goto l1281885;
l1281885: ;
_1281887 = p_1281887;
int _1282009;
_1282009 = _1031457_1281823.e3;
int _1282010;
_1282010 = gid_y_1281862 * _1282009;
int _1282011;
_1282011 = _1282010 + gid_x_1281855;
float* idx_1282012;
idx_1282012 = _1031462_1281828 + _1282011;
float _1282013;
_1282013 = *idx_1282012;
if (_1281856) goto l1281888; else goto l1282083;
l1282083: ;
pbh_upper_1281891 = _1282041;
goto l1281889;
l1281888: ;
union variant_220130 _1265919_464;
_1265919_464.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_466;
_1265920_466.e0 = 1;
_1265920_466.e1 = _1265919_464;
pbh_upper_1281891 = _1265920_466;
goto l1281889;
l1281889: ;
bh_upper_1281891 = pbh_upper_1281891;
int _1281892;
_1281892 = -1 + gid_y_1281862;
bool _1281893;
_1281893 = _1281892 < 0;
if (_1281893) goto l1281894; else goto l1282079;
l1282079: ;
union variant_220130 _1282080;
_1282080.qs32 = _1281892;
struct_BoundaryMode_220129 _1282081;
_1282081.e0 = 0;
_1282081.e1 = _1282080;
pbh_lower_1281897 = _1282081;
goto l1281895;
l1281894: ;
union variant_220130 _1265919_475;
_1265919_475.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_477;
_1265920_477.e0 = 1;
_1265920_477.e1 = _1265919_475;
pbh_lower_1281897 = _1265920_477;
goto l1281895;
l1281895: ;
bh_lower_1281897 = pbh_lower_1281897;
union variant_220130 _1281904;
_1281904 = bh_lower_1281897.e1;
unsigned int _1281898;
_1281898 = bh_upper_1281891.e0;
union variant_220130 _1281907;
_1281907 = bh_upper_1281891.e1;
unsigned int _1281900;
_1281900 = bh_lower_1281897.e0;
bool _1281899;
_1281899 = _1281898 == 0;
bool _1281901;
_1281901 = _1281900 == 0;
bool _1281902;
_1281902 = _1281899 & _1281901;
if (_1281902) goto l1281903; else goto l1282070;
l1282070: ;
bool _1282071;
_1282071 = _1281898 == 1;
if (_1282071) goto l1282072; else goto l1282074;
l1282074: ;
bool _1282075;
_1282075 = _1281900 == 1;
if (_1282075) goto l1282076; else goto l1282078;
l1282078: ;
// bottom: float r4_1265918_489;
// bottom: p_1281916 = r4_1265918_489;
goto l1281914;
l1282076: ;
float c_1282077;
c_1282077 = _1281904.pf32;
p_1281916 = c_1282077;
goto l1281914;
l1282072: ;
float c_1282073;
c_1282073 = _1281907.pf32;
p_1281916 = c_1282073;
goto l1281914;
l1281903: ;
int y_1281905;
y_1281905 = _1281904.qs32;
int x_1281908;
x_1281908 = _1281907.qs32;
int _1281906;
_1281906 = y_1281905 * _1281876;
int _1281909;
_1281909 = _1281906 + x_1281908;
float* idx_1281910;
idx_1281910 = _1031459_1281825 + _1281909;
_1281913 = __ldg(idx_1281910);
p_1281913 = _1281913;
l1281911: ;
_1281913 = p_1281913;
p_1281916 = _1281913;
goto l1281914;
l1281914: ;
_1281916 = p_1281916;
int _1281917;
_1281917 = -1 + gid_x_1281855;
bool _1281918;
_1281918 = _1281850 <= _1281917;
if (_1281918) goto l1281919; else goto l1282067;
l1282067: ;
union variant_220130 _1282068;
_1282068.qs32 = _1281917;
struct_BoundaryMode_220129 _1282069;
_1282069.e0 = 0;
_1282069.e1 = _1282068;
pbh_upper_1281922 = _1282069;
goto l1281920;
l1281919: ;
union variant_220130 _1265919_494;
_1265919_494.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_496;
_1265920_496.e0 = 1;
_1265920_496.e1 = _1265919_494;
pbh_upper_1281922 = _1265920_496;
goto l1281920;
l1281920: ;
bh_upper_1281922 = pbh_upper_1281922;
if (_1281863) goto l1281923; else goto l1282066;
l1282066: ;
pbh_lower_1281926 = _1282053;
goto l1281924;
l1281923: ;
union variant_220130 _1265919_500;
_1265919_500.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_502;
_1265920_502.e0 = 1;
_1265920_502.e1 = _1265919_500;
pbh_lower_1281926 = _1265920_502;
goto l1281924;
l1281924: ;
bh_lower_1281926 = pbh_lower_1281926;
unsigned int _1281929;
_1281929 = bh_lower_1281926.e0;
union variant_220130 _1281936;
_1281936 = bh_upper_1281922.e1;
unsigned int _1281927;
_1281927 = bh_upper_1281922.e0;
union variant_220130 _1281933;
_1281933 = bh_lower_1281926.e1;
bool _1281928;
_1281928 = _1281927 == 0;
bool _1281930;
_1281930 = _1281929 == 0;
bool _1281931;
_1281931 = _1281928 & _1281930;
if (_1281931) goto l1281932; else goto l1282057;
l1282057: ;
bool _1282058;
_1282058 = _1281927 == 1;
if (_1282058) goto l1282059; else goto l1282061;
l1282061: ;
bool _1282062;
_1282062 = _1281929 == 1;
if (_1282062) goto l1282063; else goto l1282065;
l1282065: ;
// bottom: float r4_1265918_514;
// bottom: p_1281945 = r4_1265918_514;
goto l1281943;
l1282063: ;
float c_1282064;
c_1282064 = _1281933.pf32;
p_1281945 = c_1282064;
goto l1281943;
l1282059: ;
float c_1282060;
c_1282060 = _1281936.pf32;
p_1281945 = c_1282060;
goto l1281943;
l1281932: ;
int y_1281934;
y_1281934 = _1281933.qs32;
int x_1281937;
x_1281937 = _1281936.qs32;
int _1281935;
_1281935 = y_1281934 * _1281876;
int _1281938;
_1281938 = _1281935 + x_1281937;
float* idx_1281939;
idx_1281939 = _1031459_1281825 + _1281938;
_1281942 = __ldg(idx_1281939);
p_1281942 = _1281942;
l1281940: ;
_1281942 = p_1281942;
p_1281945 = _1281942;
goto l1281943;
l1281943: ;
_1281945 = p_1281945;
int _1281946;
_1281946 = 1 + gid_x_1281855;
bool _1281947;
_1281947 = _1281850 <= _1281946;
if (_1281947) goto l1281948; else goto l1282054;
l1282054: ;
union variant_220130 _1282055;
_1282055.qs32 = _1281946;
struct_BoundaryMode_220129 _1282056;
_1282056.e0 = 0;
_1282056.e1 = _1282055;
pbh_upper_1281951 = _1282056;
goto l1281949;
l1281948: ;
union variant_220130 _1265919_519;
_1265919_519.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_521;
_1265920_521.e0 = 1;
_1265920_521.e1 = _1265919_519;
pbh_upper_1281951 = _1265920_521;
goto l1281949;
l1281949: ;
bh_upper_1281951 = pbh_upper_1281951;
if (_1281863) goto l1281952; else goto l1282051;
l1282051: ;
pbh_lower_1281955 = _1282053;
goto l1281953;
l1281952: ;
union variant_220130 _1265919_525;
_1265919_525.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_527;
_1265920_527.e0 = 1;
_1265920_527.e1 = _1265919_525;
pbh_lower_1281955 = _1265920_527;
goto l1281953;
l1281953: ;
bh_lower_1281955 = pbh_lower_1281955;
union variant_220130 _1281962;
_1281962 = bh_lower_1281955.e1;
unsigned int _1281956;
_1281956 = bh_upper_1281951.e0;
union variant_220130 _1281965;
_1281965 = bh_upper_1281951.e1;
bool _1281957;
_1281957 = _1281956 == 0;
unsigned int _1281958;
_1281958 = bh_lower_1281955.e0;
bool _1281959;
_1281959 = _1281958 == 0;
bool _1281960;
_1281960 = _1281957 & _1281959;
if (_1281960) goto l1281961; else goto l1282042;
l1282042: ;
bool _1282043;
_1282043 = _1281956 == 1;
if (_1282043) goto l1282044; else goto l1282046;
l1282046: ;
bool _1282047;
_1282047 = _1281958 == 1;
if (_1282047) goto l1282048; else goto l1282050;
l1282050: ;
// bottom: float r4_1265918_539;
// bottom: p_1281974 = r4_1265918_539;
goto l1281972;
l1282048: ;
float c_1282049;
c_1282049 = _1281962.pf32;
p_1281974 = c_1282049;
goto l1281972;
l1282044: ;
float c_1282045;
c_1282045 = _1281965.pf32;
p_1281974 = c_1282045;
goto l1281972;
l1281961: ;
int x_1281966;
x_1281966 = _1281965.qs32;
int y_1281963;
y_1281963 = _1281962.qs32;
int _1281964;
_1281964 = y_1281963 * _1281876;
int _1281967;
_1281967 = _1281964 + x_1281966;
float* idx_1281968;
idx_1281968 = _1031459_1281825 + _1281967;
_1281971 = __ldg(idx_1281968);
p_1281971 = _1281971;
l1281969: ;
_1281971 = p_1281971;
p_1281974 = _1281971;
goto l1281972;
l1281972: ;
_1281974 = p_1281974;
if (_1281856) goto l1281975; else goto l1282039;
l1282039: ;
pbh_upper_1281978 = _1282041;
goto l1281976;
l1281975: ;
union variant_220130 _1265919_540;
_1265919_540.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_542;
_1265920_542.e0 = 1;
_1265920_542.e1 = _1265919_540;
pbh_upper_1281978 = _1265920_542;
goto l1281976;
l1281976: ;
bh_upper_1281978 = pbh_upper_1281978;
int _1281979;
_1281979 = 1 + gid_y_1281862;
bool _1281980;
_1281980 = _1281979 < 0;
if (_1281980) goto l1281981; else goto l1282036;
l1282036: ;
union variant_220130 _1282037;
_1282037.qs32 = _1281979;
struct_BoundaryMode_220129 _1282038;
_1282038.e0 = 0;
_1282038.e1 = _1282037;
pbh_lower_1281984 = _1282038;
goto l1281982;
l1281981: ;
union variant_220130 _1265919_551;
_1265919_551.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_553;
_1265920_553.e0 = 1;
_1265920_553.e1 = _1265919_551;
pbh_lower_1281984 = _1265920_553;
goto l1281982;
l1281982: ;
bh_lower_1281984 = pbh_lower_1281984;
union variant_220130 _1281991;
_1281991 = bh_lower_1281984.e1;
unsigned int _1281987;
_1281987 = bh_lower_1281984.e0;
union variant_220130 _1281994;
_1281994 = bh_upper_1281978.e1;
unsigned int _1281985;
_1281985 = bh_upper_1281978.e0;
bool _1281988;
_1281988 = _1281987 == 0;
bool _1281986;
_1281986 = _1281985 == 0;
bool _1281989;
_1281989 = _1281986 & _1281988;
if (_1281989) goto l1281990; else goto l1282027;
l1282027: ;
bool _1282028;
_1282028 = _1281985 == 1;
if (_1282028) goto l1282029; else goto l1282031;
l1282031: ;
bool _1282032;
_1282032 = _1281987 == 1;
if (_1282032) goto l1282033; else goto l1282035;
l1282035: ;
// bottom: float r4_1265918_565;
// bottom: p_1282003 = r4_1265918_565;
goto l1282001;
l1282033: ;
float c_1282034;
c_1282034 = _1281991.pf32;
p_1282003 = c_1282034;
goto l1282001;
l1282029: ;
float c_1282030;
c_1282030 = _1281994.pf32;
p_1282003 = c_1282030;
goto l1282001;
l1281990: ;
int x_1281995;
x_1281995 = _1281994.qs32;
int y_1281992;
y_1281992 = _1281991.qs32;
int _1281993;
_1281993 = y_1281992 * _1281876;
int _1281996;
_1281996 = _1281993 + x_1281995;
float* idx_1281997;
idx_1281997 = _1031459_1281825 + _1281996;
_1282000 = __ldg(idx_1281997);
p_1282000 = _1282000;
l1281998: ;
_1282000 = p_1282000;
p_1282003 = _1282000;
goto l1282001;
l1282001: ;
_1282003 = p_1282003;
int _1282004;
_1282004 = _1031461_1281827.e3;
float _1282023;
_1282023 = 2.500000e-01f * _1282003;
float _1282014;
_1282014 = _1282013;
float _1282019;
_1282019 = 2.500000e-01f * _1281945;
float _1282015;
_1282015 = 2.000000e-01f * _1282014;
float _1282021;
_1282021 = 2.500000e-01f * _1281974;
float _1282017;
_1282017 = 2.500000e-01f * _1281916;
int _1282005;
_1282005 = gid_y_1281862 * _1282004;
float _1282008;
_1282008 = 2.000000e-01f * _1281887;
float _1282016;
_1282016 = _1282008 + _1282015;
float _1282018;
_1282018 = 0.000000e+00f + _1282017;
int _1282006;
_1282006 = _1282005 + gid_x_1281855;
float _1282020;
_1282020 = _1282018 + _1282019;
float* idx_1282007;
idx_1282007 = _1031458_1281824 + _1282006;
float _1282022;
_1282022 = _1282020 + _1282021;
float _1282024;
_1282024 = _1282022 + _1282023;
float val_1282025;
val_1282025 = _1282016 + _1282024;
*idx_1282007 = val_1282025;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1036899(float* _1036902_1283504, struct_Img_220118 _1036903_1283505, float* _1036904_1283506, struct_Img_220118 _1036905_1283507, struct_Img_220118 _1036906_1283508, float* _1036907_1283509) {
int _1283512;
int p_1283512;
int _1283515;
int p_1283515;
int _1283518;
int p_1283518;
int _1283521;
int p_1283521;
int _1283524;
int p_1283524;
int _1283527;
int p_1283527;
int _1283530;
int p_1283530;
struct_BoundaryMode_220129 bh_upper_1283541;
struct_BoundaryMode_220129 pbh_upper_1283541;
struct_BoundaryMode_220129 bh_upper_1283552;
struct_BoundaryMode_220129 pbh_upper_1283552;
float _1283569;
float p_1283569;
float _1283572;
float p_1283572;
struct_BoundaryMode_220129 bh_upper_1283576;
struct_BoundaryMode_220129 pbh_upper_1283576;
struct_BoundaryMode_220129 bh_upper_1283582;
struct_BoundaryMode_220129 pbh_upper_1283582;
float _1283598;
float p_1283598;
float _1283601;
float p_1283601;
struct_BoundaryMode_220129 bh_upper_1283607;
struct_BoundaryMode_220129 pbh_upper_1283607;
struct_BoundaryMode_220129 bh_upper_1283611;
struct_BoundaryMode_220129 pbh_upper_1283611;
float _1283627;
float p_1283627;
float _1283630;
float p_1283630;
struct_BoundaryMode_220129 bh_upper_1283636;
struct_BoundaryMode_220129 pbh_upper_1283636;
struct_BoundaryMode_220129 bh_upper_1283640;
struct_BoundaryMode_220129 pbh_upper_1283640;
float _1283656;
float p_1283656;
float _1283659;
float p_1283659;
struct_BoundaryMode_220129 bh_upper_1283663;
struct_BoundaryMode_220129 pbh_upper_1283663;
struct_BoundaryMode_220129 bh_upper_1283669;
struct_BoundaryMode_220129 pbh_upper_1283669;
float _1283685;
float p_1283685;
float _1283688;
float p_1283688;
_1283512 = threadIdx_x();
p_1283512 = _1283512;
l1283510: ;
_1283512 = p_1283512;
_1283515 = blockDim_x();
p_1283515 = _1283515;
l1283513: ;
_1283515 = p_1283515;
_1283518 = blockIdx_x();
p_1283518 = _1283518;
l1283516: ;
_1283518 = p_1283518;
_1283521 = threadIdx_y();
p_1283521 = _1283521;
l1283519: ;
_1283521 = p_1283521;
_1283524 = blockDim_y();
p_1283524 = _1283524;
l1283522: ;
_1283524 = p_1283524;
_1283527 = blockIdx_y();
p_1283527 = _1283527;
l1283525: ;
_1283527 = p_1283527;
_1283530 = blockDim_y();
p_1283530 = _1283530;
l1283528: ;
_1283530 = p_1283530;
int _1283535;
_1283535 = _1283515 * _1283518;
int _1283532;
_1283532 = _1036906_1283508.e1;
int _1283531;
_1283531 = _1036905_1283507.e1;
int _1283533;
_1283533 = _1283532 - 128;
int _1283534;
_1283534 = _1283533 + _1283512;
int gid_x_1283536;
gid_x_1283536 = _1283534 + _1283535;
bool _1283537;
_1283537 = _1283531 <= gid_x_1283536;
union variant_220130 _1283725;
_1283725.qs32 = gid_x_1283536;
struct_BoundaryMode_220129 _1283726;
_1283726.e0 = 0;
_1283726.e1 = _1283725;
if (_1283537) goto l1283538; else goto l1283779;
l1283779: ;
pbh_upper_1283541 = _1283726;
goto l1283539;
l1283538: ;
union variant_220130 _1265919_580;
_1265919_580.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_582;
_1265920_582.e0 = 1;
_1265920_582.e1 = _1265919_580;
pbh_upper_1283541 = _1265920_582;
goto l1283539;
l1283539: ;
bh_upper_1283541 = pbh_upper_1283541;
int _1283546;
_1283546 = _1283524 * _1283527;
int _1283543;
_1283543 = _1036906_1283508.e2;
int _1283542;
_1283542 = _1036905_1283507.e2;
int _1283544;
_1283544 = _1283543 - 1;
int _1283545;
_1283545 = _1283544 + _1283521;
int gid_y_1283547;
gid_y_1283547 = _1283545 + _1283546;
union variant_220130 _1283737;
_1283737.qs32 = gid_y_1283547;
bool _1283548;
_1283548 = _1283542 <= gid_y_1283547;
struct_BoundaryMode_220129 _1283738;
_1283738.e0 = 0;
_1283738.e1 = _1283737;
if (_1283548) goto l1283549; else goto l1283778;
l1283778: ;
pbh_upper_1283552 = _1283738;
goto l1283550;
l1283549: ;
union variant_220130 _1265919_592;
_1265919_592.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_594;
_1265920_594.e0 = 1;
_1265920_594.e1 = _1265919_592;
pbh_upper_1283552 = _1265920_594;
goto l1283550;
l1283550: ;
bh_upper_1283552 = pbh_upper_1283552;
int _1283561;
_1283561 = _1036905_1283507.e3;
union variant_220130 _1283559;
_1283559 = bh_upper_1283552.e1;
unsigned int _1283555;
_1283555 = bh_upper_1283552.e0;
union variant_220130 _1283563;
_1283563 = bh_upper_1283541.e1;
unsigned int _1283553;
_1283553 = bh_upper_1283541.e0;
bool _1283556;
_1283556 = _1283555 == 0;
bool _1283554;
_1283554 = _1283553 == 0;
bool _1283557;
_1283557 = _1283554 & _1283556;
if (_1283557) goto l1283558; else goto l1283769;
l1283769: ;
bool _1283770;
_1283770 = _1283553 == 1;
if (_1283770) goto l1283771; else goto l1283773;
l1283773: ;
bool _1283774;
_1283774 = _1283555 == 1;
if (_1283774) goto l1283775; else goto l1283777;
l1283777: ;
// bottom: float r4_1265918_607;
// bottom: p_1283572 = r4_1265918_607;
goto l1283570;
l1283775: ;
float c_1283776;
c_1283776 = _1283559.pf32;
p_1283572 = c_1283776;
goto l1283570;
l1283771: ;
float c_1283772;
c_1283772 = _1283563.pf32;
p_1283572 = c_1283772;
goto l1283570;
l1283558: ;
int y_1283560;
y_1283560 = _1283559.qs32;
int _1283562;
_1283562 = y_1283560 * _1283561;
int x_1283564;
x_1283564 = _1283563.qs32;
int _1283565;
_1283565 = _1283562 + x_1283564;
float* idx_1283566;
idx_1283566 = _1036904_1283506 + _1283565;
_1283569 = __ldg(idx_1283566);
p_1283569 = _1283569;
l1283567: ;
_1283569 = p_1283569;
p_1283572 = _1283569;
goto l1283570;
l1283570: ;
_1283572 = p_1283572;
int _1283694;
_1283694 = _1036903_1283505.e3;
int _1283695;
_1283695 = gid_y_1283547 * _1283694;
int _1283696;
_1283696 = _1283695 + gid_x_1283536;
float* idx_1283697;
idx_1283697 = _1036907_1283509 + _1283696;
float _1283698;
_1283698 = *idx_1283697;
if (_1283537) goto l1283573; else goto l1283768;
l1283768: ;
pbh_upper_1283576 = _1283726;
goto l1283574;
l1283573: ;
union variant_220130 _1265919_609;
_1265919_609.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_611;
_1265920_611.e0 = 1;
_1265920_611.e1 = _1265919_609;
pbh_upper_1283576 = _1265920_611;
goto l1283574;
l1283574: ;
bh_upper_1283576 = pbh_upper_1283576;
int _1283577;
_1283577 = -1 + gid_y_1283547;
bool _1283578;
_1283578 = _1283542 <= _1283577;
if (_1283578) goto l1283579; else goto l1283764;
l1283764: ;
union variant_220130 _1283765;
_1283765.qs32 = _1283577;
struct_BoundaryMode_220129 _1283766;
_1283766.e0 = 0;
_1283766.e1 = _1283765;
pbh_upper_1283582 = _1283766;
goto l1283580;
l1283579: ;
union variant_220130 _1265919_619;
_1265919_619.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_621;
_1265920_621.e0 = 1;
_1265920_621.e1 = _1265919_619;
pbh_upper_1283582 = _1265920_621;
goto l1283580;
l1283580: ;
bh_upper_1283582 = pbh_upper_1283582;
unsigned int _1283585;
_1283585 = bh_upper_1283582.e0;
unsigned int _1283583;
_1283583 = bh_upper_1283576.e0;
bool _1283586;
_1283586 = _1283585 == 0;
bool _1283584;
_1283584 = _1283583 == 0;
union variant_220130 _1283592;
_1283592 = bh_upper_1283576.e1;
union variant_220130 _1283589;
_1283589 = bh_upper_1283582.e1;
bool _1283587;
_1283587 = _1283584 & _1283586;
if (_1283587) goto l1283588; else goto l1283755;
l1283755: ;
bool _1283756;
_1283756 = _1283583 == 1;
if (_1283756) goto l1283757; else goto l1283759;
l1283759: ;
bool _1283760;
_1283760 = _1283585 == 1;
if (_1283760) goto l1283761; else goto l1283763;
l1283763: ;
// bottom: float r4_1265918_633;
// bottom: p_1283601 = r4_1265918_633;
goto l1283599;
l1283761: ;
float c_1283762;
c_1283762 = _1283589.pf32;
p_1283601 = c_1283762;
goto l1283599;
l1283757: ;
float c_1283758;
c_1283758 = _1283592.pf32;
p_1283601 = c_1283758;
goto l1283599;
l1283588: ;
int y_1283590;
y_1283590 = _1283589.qs32;
int _1283591;
_1283591 = y_1283590 * _1283561;
int x_1283593;
x_1283593 = _1283592.qs32;
int _1283594;
_1283594 = _1283591 + x_1283593;
float* idx_1283595;
idx_1283595 = _1036904_1283506 + _1283594;
_1283598 = __ldg(idx_1283595);
p_1283598 = _1283598;
l1283596: ;
_1283598 = p_1283598;
p_1283601 = _1283598;
goto l1283599;
l1283599: ;
_1283601 = p_1283601;
int _1283602;
_1283602 = -1 + gid_x_1283536;
bool _1283603;
_1283603 = _1283531 <= _1283602;
if (_1283603) goto l1283604; else goto l1283752;
l1283752: ;
union variant_220130 _1283753;
_1283753.qs32 = _1283602;
struct_BoundaryMode_220129 _1283754;
_1283754.e0 = 0;
_1283754.e1 = _1283753;
pbh_upper_1283607 = _1283754;
goto l1283605;
l1283604: ;
union variant_220130 _1265919_638;
_1265919_638.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_640;
_1265920_640.e0 = 1;
_1265920_640.e1 = _1265919_638;
pbh_upper_1283607 = _1265920_640;
goto l1283605;
l1283605: ;
bh_upper_1283607 = pbh_upper_1283607;
if (_1283548) goto l1283608; else goto l1283751;
l1283751: ;
pbh_upper_1283611 = _1283738;
goto l1283609;
l1283608: ;
union variant_220130 _1265919_644;
_1265919_644.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_646;
_1265920_646.e0 = 1;
_1265920_646.e1 = _1265919_644;
pbh_upper_1283611 = _1265920_646;
goto l1283609;
l1283609: ;
bh_upper_1283611 = pbh_upper_1283611;
unsigned int _1283614;
_1283614 = bh_upper_1283611.e0;
unsigned int _1283612;
_1283612 = bh_upper_1283607.e0;
union variant_220130 _1283621;
_1283621 = bh_upper_1283607.e1;
bool _1283613;
_1283613 = _1283612 == 0;
union variant_220130 _1283618;
_1283618 = bh_upper_1283611.e1;
bool _1283615;
_1283615 = _1283614 == 0;
bool _1283616;
_1283616 = _1283613 & _1283615;
if (_1283616) goto l1283617; else goto l1283742;
l1283742: ;
bool _1283743;
_1283743 = _1283612 == 1;
if (_1283743) goto l1283744; else goto l1283746;
l1283746: ;
bool _1283747;
_1283747 = _1283614 == 1;
if (_1283747) goto l1283748; else goto l1283750;
l1283750: ;
// bottom: float r4_1265918_658;
// bottom: p_1283630 = r4_1265918_658;
goto l1283628;
l1283748: ;
float c_1283749;
c_1283749 = _1283618.pf32;
p_1283630 = c_1283749;
goto l1283628;
l1283744: ;
float c_1283745;
c_1283745 = _1283621.pf32;
p_1283630 = c_1283745;
goto l1283628;
l1283617: ;
int y_1283619;
y_1283619 = _1283618.qs32;
int _1283620;
_1283620 = y_1283619 * _1283561;
int x_1283622;
x_1283622 = _1283621.qs32;
int _1283623;
_1283623 = _1283620 + x_1283622;
float* idx_1283624;
idx_1283624 = _1036904_1283506 + _1283623;
_1283627 = __ldg(idx_1283624);
p_1283627 = _1283627;
l1283625: ;
_1283627 = p_1283627;
p_1283630 = _1283627;
goto l1283628;
l1283628: ;
_1283630 = p_1283630;
int _1283631;
_1283631 = 1 + gid_x_1283536;
bool _1283632;
_1283632 = _1283531 <= _1283631;
if (_1283632) goto l1283633; else goto l1283739;
l1283739: ;
union variant_220130 _1283740;
_1283740.qs32 = _1283631;
struct_BoundaryMode_220129 _1283741;
_1283741.e0 = 0;
_1283741.e1 = _1283740;
pbh_upper_1283636 = _1283741;
goto l1283634;
l1283633: ;
union variant_220130 _1265919_663;
_1265919_663.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_665;
_1265920_665.e0 = 1;
_1265920_665.e1 = _1265919_663;
pbh_upper_1283636 = _1265920_665;
goto l1283634;
l1283634: ;
bh_upper_1283636 = pbh_upper_1283636;
if (_1283548) goto l1283637; else goto l1283736;
l1283736: ;
pbh_upper_1283640 = _1283738;
goto l1283638;
l1283637: ;
union variant_220130 _1265919_669;
_1265919_669.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_671;
_1265920_671.e0 = 1;
_1265920_671.e1 = _1265919_669;
pbh_upper_1283640 = _1265920_671;
goto l1283638;
l1283638: ;
bh_upper_1283640 = pbh_upper_1283640;
unsigned int _1283643;
_1283643 = bh_upper_1283640.e0;
union variant_220130 _1283650;
_1283650 = bh_upper_1283636.e1;
unsigned int _1283641;
_1283641 = bh_upper_1283636.e0;
bool _1283642;
_1283642 = _1283641 == 0;
union variant_220130 _1283647;
_1283647 = bh_upper_1283640.e1;
bool _1283644;
_1283644 = _1283643 == 0;
bool _1283645;
_1283645 = _1283642 & _1283644;
if (_1283645) goto l1283646; else goto l1283727;
l1283727: ;
bool _1283728;
_1283728 = _1283641 == 1;
if (_1283728) goto l1283729; else goto l1283731;
l1283731: ;
bool _1283732;
_1283732 = _1283643 == 1;
if (_1283732) goto l1283733; else goto l1283735;
l1283735: ;
// bottom: float r4_1265918_683;
// bottom: p_1283659 = r4_1265918_683;
goto l1283657;
l1283733: ;
float c_1283734;
c_1283734 = _1283647.pf32;
p_1283659 = c_1283734;
goto l1283657;
l1283729: ;
float c_1283730;
c_1283730 = _1283650.pf32;
p_1283659 = c_1283730;
goto l1283657;
l1283646: ;
int y_1283648;
y_1283648 = _1283647.qs32;
int x_1283651;
x_1283651 = _1283650.qs32;
int _1283649;
_1283649 = y_1283648 * _1283561;
int _1283652;
_1283652 = _1283649 + x_1283651;
float* idx_1283653;
idx_1283653 = _1036904_1283506 + _1283652;
_1283656 = __ldg(idx_1283653);
p_1283656 = _1283656;
l1283654: ;
_1283656 = p_1283656;
p_1283659 = _1283656;
goto l1283657;
l1283657: ;
_1283659 = p_1283659;
if (_1283537) goto l1283660; else goto l1283724;
l1283724: ;
pbh_upper_1283663 = _1283726;
goto l1283661;
l1283660: ;
union variant_220130 _1265919_684;
_1265919_684.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_686;
_1265920_686.e0 = 1;
_1265920_686.e1 = _1265919_684;
pbh_upper_1283663 = _1265920_686;
goto l1283661;
l1283661: ;
bh_upper_1283663 = pbh_upper_1283663;
int _1283664;
_1283664 = 1 + gid_y_1283547;
bool _1283665;
_1283665 = _1283542 <= _1283664;
if (_1283665) goto l1283666; else goto l1283721;
l1283721: ;
union variant_220130 _1283722;
_1283722.qs32 = _1283664;
struct_BoundaryMode_220129 _1283723;
_1283723.e0 = 0;
_1283723.e1 = _1283722;
pbh_upper_1283669 = _1283723;
goto l1283667;
l1283666: ;
union variant_220130 _1265919_694;
_1265919_694.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_696;
_1265920_696.e0 = 1;
_1265920_696.e1 = _1265919_694;
pbh_upper_1283669 = _1265920_696;
goto l1283667;
l1283667: ;
bh_upper_1283669 = pbh_upper_1283669;
unsigned int _1283672;
_1283672 = bh_upper_1283669.e0;
union variant_220130 _1283679;
_1283679 = bh_upper_1283663.e1;
unsigned int _1283670;
_1283670 = bh_upper_1283663.e0;
bool _1283673;
_1283673 = _1283672 == 0;
union variant_220130 _1283676;
_1283676 = bh_upper_1283669.e1;
bool _1283671;
_1283671 = _1283670 == 0;
bool _1283674;
_1283674 = _1283671 & _1283673;
if (_1283674) goto l1283675; else goto l1283712;
l1283712: ;
bool _1283713;
_1283713 = _1283670 == 1;
if (_1283713) goto l1283714; else goto l1283716;
l1283716: ;
bool _1283717;
_1283717 = _1283672 == 1;
if (_1283717) goto l1283718; else goto l1283720;
l1283720: ;
// bottom: float r4_1265918_708;
// bottom: p_1283688 = r4_1265918_708;
goto l1283686;
l1283718: ;
float c_1283719;
c_1283719 = _1283676.pf32;
p_1283688 = c_1283719;
goto l1283686;
l1283714: ;
float c_1283715;
c_1283715 = _1283679.pf32;
p_1283688 = c_1283715;
goto l1283686;
l1283675: ;
int y_1283677;
y_1283677 = _1283676.qs32;
int x_1283680;
x_1283680 = _1283679.qs32;
int _1283678;
_1283678 = y_1283677 * _1283561;
int _1283681;
_1283681 = _1283678 + x_1283680;
float* idx_1283682;
idx_1283682 = _1036904_1283506 + _1283681;
_1283685 = __ldg(idx_1283682);
p_1283685 = _1283685;
l1283683: ;
_1283685 = p_1283685;
p_1283688 = _1283685;
goto l1283686;
l1283686: ;
_1283688 = p_1283688;
float _1283706;
_1283706 = 2.500000e-01f * _1283659;
float _1283699;
_1283699 = _1283698;
int _1283689;
_1283689 = _1036906_1283508.e3;
float _1283700;
_1283700 = 2.000000e-01f * _1283699;
float _1283702;
_1283702 = 2.500000e-01f * _1283601;
float _1283703;
_1283703 = 0.000000e+00f + _1283702;
float _1283693;
_1283693 = 2.000000e-01f * _1283572;
float _1283704;
_1283704 = 2.500000e-01f * _1283630;
float _1283708;
_1283708 = 2.500000e-01f * _1283688;
float _1283701;
_1283701 = _1283693 + _1283700;
int _1283690;
_1283690 = gid_y_1283547 * _1283689;
float _1283705;
_1283705 = _1283703 + _1283704;
int _1283691;
_1283691 = _1283690 + gid_x_1283536;
float _1283707;
_1283707 = _1283705 + _1283706;
float* idx_1283692;
idx_1283692 = _1036902_1283504 + _1283691;
float _1283709;
_1283709 = _1283707 + _1283708;
float val_1283710;
val_1283710 = _1283701 + _1283709;
*idx_1283692 = val_1283710;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1034051(float* _1034054_1273917, struct_Img_220118 _1034055_1273918, float* _1034056_1273919, struct_Img_220118 _1034057_1273920, struct_Img_220118 _1034058_1273921, float* _1034059_1273922) {
int _1273925;
int p_1273925;
int _1273928;
int p_1273928;
int _1273931;
int p_1273931;
int _1273934;
int p_1273934;
int _1273937;
int p_1273937;
int _1273940;
int p_1273940;
int _1273943;
int p_1273943;
struct_BoundaryMode_220129 bh_lower_1273950;
struct_BoundaryMode_220129 pbh_lower_1273950;
struct_BoundaryMode_220129 bh_upper_1273961;
struct_BoundaryMode_220129 pbh_upper_1273961;
float _1273978;
float p_1273978;
float _1273981;
float p_1273981;
struct_BoundaryMode_220129 bh_lower_1273985;
struct_BoundaryMode_220129 pbh_lower_1273985;
struct_BoundaryMode_220129 bh_upper_1273991;
struct_BoundaryMode_220129 pbh_upper_1273991;
float _1274007;
float p_1274007;
float _1274010;
float p_1274010;
struct_BoundaryMode_220129 bh_lower_1274016;
struct_BoundaryMode_220129 pbh_lower_1274016;
struct_BoundaryMode_220129 bh_upper_1274020;
struct_BoundaryMode_220129 pbh_upper_1274020;
float _1274036;
float p_1274036;
float _1274039;
float p_1274039;
struct_BoundaryMode_220129 bh_lower_1274045;
struct_BoundaryMode_220129 pbh_lower_1274045;
struct_BoundaryMode_220129 bh_upper_1274049;
struct_BoundaryMode_220129 pbh_upper_1274049;
float _1274065;
float p_1274065;
float _1274068;
float p_1274068;
struct_BoundaryMode_220129 bh_lower_1274072;
struct_BoundaryMode_220129 pbh_lower_1274072;
struct_BoundaryMode_220129 bh_upper_1274078;
struct_BoundaryMode_220129 pbh_upper_1274078;
float _1274094;
float p_1274094;
float _1274097;
float p_1274097;
_1273925 = threadIdx_x();
p_1273925 = _1273925;
l1273923: ;
_1273925 = p_1273925;
_1273928 = blockDim_x();
p_1273928 = _1273928;
l1273926: ;
_1273928 = p_1273928;
_1273931 = blockIdx_x();
p_1273931 = _1273931;
l1273929: ;
_1273931 = p_1273931;
_1273934 = threadIdx_y();
p_1273934 = _1273934;
l1273932: ;
_1273934 = p_1273934;
_1273937 = blockDim_y();
p_1273937 = _1273937;
l1273935: ;
_1273937 = p_1273937;
_1273940 = blockIdx_y();
p_1273940 = _1273940;
l1273938: ;
_1273940 = p_1273940;
_1273943 = blockDim_y();
p_1273943 = _1273943;
l1273941: ;
_1273943 = p_1273943;
int _1273944;
_1273944 = _1273928 * _1273931;
int gid_x_1273945;
gid_x_1273945 = _1273925 + _1273944;
bool _1273946;
_1273946 = gid_x_1273945 < 0;
union variant_220130 _1274134;
_1274134.qs32 = gid_x_1273945;
struct_BoundaryMode_220129 _1274135;
_1274135.e0 = 0;
_1274135.e1 = _1274134;
if (_1273946) goto l1273947; else goto l1274188;
l1274188: ;
pbh_lower_1273950 = _1274135;
goto l1273948;
l1273947: ;
union variant_220130 _1265919_721;
_1265919_721.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_723;
_1265920_723.e0 = 1;
_1265920_723.e1 = _1265919_721;
pbh_lower_1273950 = _1265920_723;
goto l1273948;
l1273948: ;
bh_lower_1273950 = pbh_lower_1273950;
int _1273952;
_1273952 = _1034058_1273921.e2;
int _1273951;
_1273951 = _1034057_1273920.e2;
int _1273955;
_1273955 = _1273937 * _1273940;
int _1273953;
_1273953 = _1273952 - 1;
int _1273954;
_1273954 = _1273953 + _1273934;
int gid_y_1273956;
gid_y_1273956 = _1273954 + _1273955;
bool _1273957;
_1273957 = _1273951 <= gid_y_1273956;
union variant_220130 _1274146;
_1274146.qs32 = gid_y_1273956;
struct_BoundaryMode_220129 _1274147;
_1274147.e0 = 0;
_1274147.e1 = _1274146;
if (_1273957) goto l1273958; else goto l1274187;
l1274187: ;
pbh_upper_1273961 = _1274147;
goto l1273959;
l1273958: ;
union variant_220130 _1265919_733;
_1265919_733.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_735;
_1265920_735.e0 = 1;
_1265920_735.e1 = _1265919_733;
pbh_upper_1273961 = _1265920_735;
goto l1273959;
l1273959: ;
bh_upper_1273961 = pbh_upper_1273961;
unsigned int _1273964;
_1273964 = bh_upper_1273961.e0;
unsigned int _1273962;
_1273962 = bh_lower_1273950.e0;
int _1273970;
_1273970 = _1034057_1273920.e3;
bool _1273965;
_1273965 = _1273964 == 0;
union variant_220130 _1273972;
_1273972 = bh_lower_1273950.e1;
bool _1273963;
_1273963 = _1273962 == 0;
union variant_220130 _1273968;
_1273968 = bh_upper_1273961.e1;
bool _1273966;
_1273966 = _1273963 & _1273965;
if (_1273966) goto l1273967; else goto l1274178;
l1274178: ;
bool _1274179;
_1274179 = _1273962 == 1;
if (_1274179) goto l1274180; else goto l1274182;
l1274182: ;
bool _1274183;
_1274183 = _1273964 == 1;
if (_1274183) goto l1274184; else goto l1274186;
l1274186: ;
// bottom: float r4_1265918_748;
// bottom: p_1273981 = r4_1265918_748;
goto l1273979;
l1274184: ;
float c_1274185;
c_1274185 = _1273968.pf32;
p_1273981 = c_1274185;
goto l1273979;
l1274180: ;
float c_1274181;
c_1274181 = _1273972.pf32;
p_1273981 = c_1274181;
goto l1273979;
l1273967: ;
int x_1273973;
x_1273973 = _1273972.qs32;
int y_1273969;
y_1273969 = _1273968.qs32;
int _1273971;
_1273971 = y_1273969 * _1273970;
int _1273974;
_1273974 = _1273971 + x_1273973;
float* idx_1273975;
idx_1273975 = _1034056_1273919 + _1273974;
_1273978 = __ldg(idx_1273975);
p_1273978 = _1273978;
l1273976: ;
_1273978 = p_1273978;
p_1273981 = _1273978;
goto l1273979;
l1273979: ;
_1273981 = p_1273981;
int _1274103;
_1274103 = _1034055_1273918.e3;
int _1274104;
_1274104 = gid_y_1273956 * _1274103;
int _1274105;
_1274105 = _1274104 + gid_x_1273945;
float* idx_1274106;
idx_1274106 = _1034059_1273922 + _1274105;
float _1274107;
_1274107 = *idx_1274106;
if (_1273946) goto l1273982; else goto l1274177;
l1274177: ;
pbh_lower_1273985 = _1274135;
goto l1273983;
l1273982: ;
union variant_220130 _1265919_750;
_1265919_750.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_752;
_1265920_752.e0 = 1;
_1265920_752.e1 = _1265919_750;
pbh_lower_1273985 = _1265920_752;
goto l1273983;
l1273983: ;
bh_lower_1273985 = pbh_lower_1273985;
int _1273986;
_1273986 = -1 + gid_y_1273956;
bool _1273987;
_1273987 = _1273951 <= _1273986;
if (_1273987) goto l1273988; else goto l1274173;
l1274173: ;
union variant_220130 _1274174;
_1274174.qs32 = _1273986;
struct_BoundaryMode_220129 _1274175;
_1274175.e0 = 0;
_1274175.e1 = _1274174;
pbh_upper_1273991 = _1274175;
goto l1273989;
l1273988: ;
union variant_220130 _1265919_760;
_1265919_760.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_762;
_1265920_762.e0 = 1;
_1265920_762.e1 = _1265919_760;
pbh_upper_1273991 = _1265920_762;
goto l1273989;
l1273989: ;
bh_upper_1273991 = pbh_upper_1273991;
union variant_220130 _1273998;
_1273998 = bh_upper_1273991.e1;
unsigned int _1273994;
_1273994 = bh_upper_1273991.e0;
union variant_220130 _1274001;
_1274001 = bh_lower_1273985.e1;
unsigned int _1273992;
_1273992 = bh_lower_1273985.e0;
bool _1273995;
_1273995 = _1273994 == 0;
bool _1273993;
_1273993 = _1273992 == 0;
bool _1273996;
_1273996 = _1273993 & _1273995;
if (_1273996) goto l1273997; else goto l1274164;
l1274164: ;
bool _1274165;
_1274165 = _1273992 == 1;
if (_1274165) goto l1274166; else goto l1274168;
l1274168: ;
bool _1274169;
_1274169 = _1273994 == 1;
if (_1274169) goto l1274170; else goto l1274172;
l1274172: ;
// bottom: float r4_1265918_774;
// bottom: p_1274010 = r4_1265918_774;
goto l1274008;
l1274170: ;
float c_1274171;
c_1274171 = _1273998.pf32;
p_1274010 = c_1274171;
goto l1274008;
l1274166: ;
float c_1274167;
c_1274167 = _1274001.pf32;
p_1274010 = c_1274167;
goto l1274008;
l1273997: ;
int y_1273999;
y_1273999 = _1273998.qs32;
int x_1274002;
x_1274002 = _1274001.qs32;
int _1274000;
_1274000 = y_1273999 * _1273970;
int _1274003;
_1274003 = _1274000 + x_1274002;
float* idx_1274004;
idx_1274004 = _1034056_1273919 + _1274003;
_1274007 = __ldg(idx_1274004);
p_1274007 = _1274007;
l1274005: ;
_1274007 = p_1274007;
p_1274010 = _1274007;
goto l1274008;
l1274008: ;
_1274010 = p_1274010;
int _1274011;
_1274011 = -1 + gid_x_1273945;
bool _1274012;
_1274012 = _1274011 < 0;
if (_1274012) goto l1274013; else goto l1274161;
l1274161: ;
union variant_220130 _1274162;
_1274162.qs32 = _1274011;
struct_BoundaryMode_220129 _1274163;
_1274163.e0 = 0;
_1274163.e1 = _1274162;
pbh_lower_1274016 = _1274163;
goto l1274014;
l1274013: ;
union variant_220130 _1265919_780;
_1265919_780.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_782;
_1265920_782.e0 = 1;
_1265920_782.e1 = _1265919_780;
pbh_lower_1274016 = _1265920_782;
goto l1274014;
l1274014: ;
bh_lower_1274016 = pbh_lower_1274016;
if (_1273957) goto l1274017; else goto l1274160;
l1274160: ;
pbh_upper_1274020 = _1274147;
goto l1274018;
l1274017: ;
union variant_220130 _1265919_786;
_1265919_786.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_788;
_1265920_788.e0 = 1;
_1265920_788.e1 = _1265919_786;
pbh_upper_1274020 = _1265920_788;
goto l1274018;
l1274018: ;
bh_upper_1274020 = pbh_upper_1274020;
unsigned int _1274021;
_1274021 = bh_lower_1274016.e0;
unsigned int _1274023;
_1274023 = bh_upper_1274020.e0;
union variant_220130 _1274030;
_1274030 = bh_lower_1274016.e1;
union variant_220130 _1274027;
_1274027 = bh_upper_1274020.e1;
bool _1274022;
_1274022 = _1274021 == 0;
bool _1274024;
_1274024 = _1274023 == 0;
bool _1274025;
_1274025 = _1274022 & _1274024;
if (_1274025) goto l1274026; else goto l1274151;
l1274151: ;
bool _1274152;
_1274152 = _1274021 == 1;
if (_1274152) goto l1274153; else goto l1274155;
l1274155: ;
bool _1274156;
_1274156 = _1274023 == 1;
if (_1274156) goto l1274157; else goto l1274159;
l1274159: ;
// bottom: float r4_1265918_800;
// bottom: p_1274039 = r4_1265918_800;
goto l1274037;
l1274157: ;
float c_1274158;
c_1274158 = _1274027.pf32;
p_1274039 = c_1274158;
goto l1274037;
l1274153: ;
float c_1274154;
c_1274154 = _1274030.pf32;
p_1274039 = c_1274154;
goto l1274037;
l1274026: ;
int x_1274031;
x_1274031 = _1274030.qs32;
int y_1274028;
y_1274028 = _1274027.qs32;
int _1274029;
_1274029 = y_1274028 * _1273970;
int _1274032;
_1274032 = _1274029 + x_1274031;
float* idx_1274033;
idx_1274033 = _1034056_1273919 + _1274032;
_1274036 = __ldg(idx_1274033);
p_1274036 = _1274036;
l1274034: ;
_1274036 = p_1274036;
p_1274039 = _1274036;
goto l1274037;
l1274037: ;
_1274039 = p_1274039;
int _1274040;
_1274040 = 1 + gid_x_1273945;
bool _1274041;
_1274041 = _1274040 < 0;
if (_1274041) goto l1274042; else goto l1274148;
l1274148: ;
union variant_220130 _1274149;
_1274149.qs32 = _1274040;
struct_BoundaryMode_220129 _1274150;
_1274150.e0 = 0;
_1274150.e1 = _1274149;
pbh_lower_1274045 = _1274150;
goto l1274043;
l1274042: ;
union variant_220130 _1265919_806;
_1265919_806.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_808;
_1265920_808.e0 = 1;
_1265920_808.e1 = _1265919_806;
pbh_lower_1274045 = _1265920_808;
goto l1274043;
l1274043: ;
bh_lower_1274045 = pbh_lower_1274045;
if (_1273957) goto l1274046; else goto l1274145;
l1274145: ;
pbh_upper_1274049 = _1274147;
goto l1274047;
l1274046: ;
union variant_220130 _1265919_812;
_1265919_812.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_814;
_1265920_814.e0 = 1;
_1265920_814.e1 = _1265919_812;
pbh_upper_1274049 = _1265920_814;
goto l1274047;
l1274047: ;
bh_upper_1274049 = pbh_upper_1274049;
union variant_220130 _1274056;
_1274056 = bh_upper_1274049.e1;
unsigned int _1274050;
_1274050 = bh_lower_1274045.e0;
union variant_220130 _1274059;
_1274059 = bh_lower_1274045.e1;
unsigned int _1274052;
_1274052 = bh_upper_1274049.e0;
bool _1274051;
_1274051 = _1274050 == 0;
bool _1274053;
_1274053 = _1274052 == 0;
bool _1274054;
_1274054 = _1274051 & _1274053;
if (_1274054) goto l1274055; else goto l1274136;
l1274136: ;
bool _1274137;
_1274137 = _1274050 == 1;
if (_1274137) goto l1274138; else goto l1274140;
l1274140: ;
bool _1274141;
_1274141 = _1274052 == 1;
if (_1274141) goto l1274142; else goto l1274144;
l1274144: ;
// bottom: float r4_1265918_826;
// bottom: p_1274068 = r4_1265918_826;
goto l1274066;
l1274142: ;
float c_1274143;
c_1274143 = _1274056.pf32;
p_1274068 = c_1274143;
goto l1274066;
l1274138: ;
float c_1274139;
c_1274139 = _1274059.pf32;
p_1274068 = c_1274139;
goto l1274066;
l1274055: ;
int x_1274060;
x_1274060 = _1274059.qs32;
int y_1274057;
y_1274057 = _1274056.qs32;
int _1274058;
_1274058 = y_1274057 * _1273970;
int _1274061;
_1274061 = _1274058 + x_1274060;
float* idx_1274062;
idx_1274062 = _1034056_1273919 + _1274061;
_1274065 = __ldg(idx_1274062);
p_1274065 = _1274065;
l1274063: ;
_1274065 = p_1274065;
p_1274068 = _1274065;
goto l1274066;
l1274066: ;
_1274068 = p_1274068;
if (_1273946) goto l1274069; else goto l1274133;
l1274133: ;
pbh_lower_1274072 = _1274135;
goto l1274070;
l1274069: ;
union variant_220130 _1265919_827;
_1265919_827.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_829;
_1265920_829.e0 = 1;
_1265920_829.e1 = _1265919_827;
pbh_lower_1274072 = _1265920_829;
goto l1274070;
l1274070: ;
bh_lower_1274072 = pbh_lower_1274072;
int _1274073;
_1274073 = 1 + gid_y_1273956;
bool _1274074;
_1274074 = _1273951 <= _1274073;
if (_1274074) goto l1274075; else goto l1274130;
l1274130: ;
union variant_220130 _1274131;
_1274131.qs32 = _1274073;
struct_BoundaryMode_220129 _1274132;
_1274132.e0 = 0;
_1274132.e1 = _1274131;
pbh_upper_1274078 = _1274132;
goto l1274076;
l1274075: ;
union variant_220130 _1265919_837;
_1265919_837.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_839;
_1265920_839.e0 = 1;
_1265920_839.e1 = _1265919_837;
pbh_upper_1274078 = _1265920_839;
goto l1274076;
l1274076: ;
bh_upper_1274078 = pbh_upper_1274078;
union variant_220130 _1274085;
_1274085 = bh_upper_1274078.e1;
union variant_220130 _1274088;
_1274088 = bh_lower_1274072.e1;
unsigned int _1274079;
_1274079 = bh_lower_1274072.e0;
unsigned int _1274081;
_1274081 = bh_upper_1274078.e0;
bool _1274082;
_1274082 = _1274081 == 0;
bool _1274080;
_1274080 = _1274079 == 0;
bool _1274083;
_1274083 = _1274080 & _1274082;
if (_1274083) goto l1274084; else goto l1274121;
l1274121: ;
bool _1274122;
_1274122 = _1274079 == 1;
if (_1274122) goto l1274123; else goto l1274125;
l1274125: ;
bool _1274126;
_1274126 = _1274081 == 1;
if (_1274126) goto l1274127; else goto l1274129;
l1274129: ;
// bottom: float r4_1265918_851;
// bottom: p_1274097 = r4_1265918_851;
goto l1274095;
l1274127: ;
float c_1274128;
c_1274128 = _1274085.pf32;
p_1274097 = c_1274128;
goto l1274095;
l1274123: ;
float c_1274124;
c_1274124 = _1274088.pf32;
p_1274097 = c_1274124;
goto l1274095;
l1274084: ;
int y_1274086;
y_1274086 = _1274085.qs32;
int x_1274089;
x_1274089 = _1274088.qs32;
int _1274087;
_1274087 = y_1274086 * _1273970;
int _1274090;
_1274090 = _1274087 + x_1274089;
float* idx_1274091;
idx_1274091 = _1034056_1273919 + _1274090;
_1274094 = __ldg(idx_1274091);
p_1274094 = _1274094;
l1274092: ;
_1274094 = p_1274094;
p_1274097 = _1274094;
goto l1274095;
l1274095: ;
_1274097 = p_1274097;
float _1274108;
_1274108 = _1274107;
float _1274115;
_1274115 = 2.500000e-01f * _1274068;
float _1274109;
_1274109 = 2.000000e-01f * _1274108;
float _1274117;
_1274117 = 2.500000e-01f * _1274097;
float _1274113;
_1274113 = 2.500000e-01f * _1274039;
float _1274102;
_1274102 = 2.000000e-01f * _1273981;
int _1274098;
_1274098 = _1034058_1273921.e3;
float _1274110;
_1274110 = _1274102 + _1274109;
float _1274111;
_1274111 = 2.500000e-01f * _1274010;
int _1274099;
_1274099 = gid_y_1273956 * _1274098;
float _1274112;
_1274112 = 0.000000e+00f + _1274111;
int _1274100;
_1274100 = _1274099 + gid_x_1273945;
float _1274114;
_1274114 = _1274112 + _1274113;
float* idx_1274101;
idx_1274101 = _1034054_1273917 + _1274100;
float _1274116;
_1274116 = _1274114 + _1274115;
float _1274118;
_1274118 = _1274116 + _1274117;
float val_1274119;
val_1274119 = _1274110 + _1274118;
*idx_1274101 = val_1274119;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1011990(struct_Img_220118 _1011993_1267370, struct_Img_220118 _1011994_1267371, float* _1011995_1267372, struct_Img_220118 _1011996_1267373, float* _1011997_1267374, float* _1011998_1267375) {
int _1267378;
int p_1267378;
int _1267381;
int p_1267381;
int _1267384;
int p_1267384;
int _1267387;
int p_1267387;
int _1267390;
int p_1267390;
int _1267393;
int p_1267393;
int _1267396;
int p_1267396;
struct_BoundaryMode_220129 bh_upper_1267408;
struct_BoundaryMode_220129 pbh_upper_1267408;
float _1267423;
float p_1267423;
float _1267426;
float p_1267426;
struct_BoundaryMode_220129 bh_upper_1267432;
struct_BoundaryMode_220129 pbh_upper_1267432;
float _1267444;
float p_1267444;
float _1267447;
float p_1267447;
struct_BoundaryMode_220129 bh_upper_1267451;
struct_BoundaryMode_220129 pbh_upper_1267451;
float _1267463;
float p_1267463;
float _1267466;
float p_1267466;
struct_BoundaryMode_220129 bh_upper_1267470;
struct_BoundaryMode_220129 pbh_upper_1267470;
float _1267482;
float p_1267482;
float _1267485;
float p_1267485;
struct_BoundaryMode_220129 bh_upper_1267491;
struct_BoundaryMode_220129 pbh_upper_1267491;
float _1267503;
float p_1267503;
float _1267506;
float p_1267506;
_1267378 = threadIdx_x();
p_1267378 = _1267378;
l1267376: ;
_1267378 = p_1267378;
_1267381 = blockDim_x();
p_1267381 = _1267381;
l1267379: ;
_1267381 = p_1267381;
_1267384 = blockIdx_x();
p_1267384 = _1267384;
l1267382: ;
_1267384 = p_1267384;
_1267387 = threadIdx_y();
p_1267387 = _1267387;
l1267385: ;
_1267387 = p_1267387;
_1267390 = blockDim_y();
p_1267390 = _1267390;
l1267388: ;
_1267390 = p_1267390;
_1267393 = blockIdx_y();
p_1267393 = _1267393;
l1267391: ;
_1267393 = p_1267393;
_1267396 = blockDim_y();
p_1267396 = _1267396;
l1267394: ;
_1267396 = p_1267396;
int _1267398;
_1267398 = _1011993_1267370.e2;
int _1267402;
_1267402 = _1267390 * _1267393;
int _1267399;
_1267399 = _1011996_1267373.e2;
int _1267400;
_1267400 = _1267399 - 1;
int _1267401;
_1267401 = _1267400 + _1267387;
int gid_y_1267403;
gid_y_1267403 = _1267401 + _1267402;
union variant_220130 _1267546;
_1267546.qs32 = gid_y_1267403;
bool _1267404;
_1267404 = _1267398 <= gid_y_1267403;
struct_BoundaryMode_220129 _1267547;
_1267547.e0 = 0;
_1267547.e1 = _1267546;
if (_1267404) goto l1267405; else goto l1267568;
l1267568: ;
pbh_upper_1267408 = _1267547;
goto l1267406;
l1267405: ;
union variant_220130 _1265919_866;
_1265919_866.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_868;
_1265920_868.e0 = 1;
_1265920_868.e1 = _1265919_866;
pbh_upper_1267408 = _1265920_868;
goto l1267406;
l1267406: ;
bh_upper_1267408 = pbh_upper_1267408;
union variant_220130 _1267412;
_1267412 = bh_upper_1267408.e1;
unsigned int _1267409;
_1267409 = bh_upper_1267408.e0;
int _1267414;
_1267414 = _1011993_1267370.e3;
int _1267416;
_1267416 = _1267381 * _1267384;
bool _1267410;
_1267410 = _1267409 == 0;
int gid_x_1267417;
gid_x_1267417 = _1267378 + _1267416;
if (_1267410) goto l1267411; else goto l1267563;
l1267563: ;
bool _1267564;
_1267564 = _1267409 == 1;
if (_1267564) goto l1267565; else goto l1267567;
l1267567: ;
// bottom: float r4_1265918_877;
// bottom: p_1267426 = r4_1265918_877;
goto l1267424;
l1267565: ;
float c_1267566;
c_1267566 = _1267412.pf32;
p_1267426 = c_1267566;
goto l1267424;
l1267411: ;
int y_1267413;
y_1267413 = _1267412.qs32;
int _1267415;
_1267415 = y_1267413 * _1267414;
int _1267418;
_1267418 = _1267415 + gid_x_1267417;
int _1267419;
_1267419 = 128 + _1267418;
float* idx_1267420;
idx_1267420 = _1011997_1267374 + _1267419;
_1267423 = __ldg(idx_1267420);
p_1267423 = _1267423;
l1267421: ;
_1267423 = p_1267423;
p_1267426 = _1267423;
goto l1267424;
l1267424: ;
_1267426 = p_1267426;
int _1267513;
_1267513 = _1011994_1267371.e3;
int _1267514;
_1267514 = gid_y_1267403 * _1267513;
int _1267515;
_1267515 = _1267514 + gid_x_1267417;
int _1267427;
_1267427 = -1 + gid_y_1267403;
int _1267516;
_1267516 = 128 + _1267515;
bool _1267428;
_1267428 = _1267398 <= _1267427;
float* idx_1267517;
idx_1267517 = _1011998_1267375 + _1267516;
float _1267518;
_1267518 = *idx_1267517;
if (_1267428) goto l1267429; else goto l1267560;
l1267560: ;
union variant_220130 _1267561;
_1267561.qs32 = _1267427;
struct_BoundaryMode_220129 _1267562;
_1267562.e0 = 0;
_1267562.e1 = _1267561;
pbh_upper_1267432 = _1267562;
goto l1267430;
l1267429: ;
union variant_220130 _1265919_885;
_1265919_885.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_887;
_1265920_887.e0 = 1;
_1265920_887.e1 = _1265919_885;
pbh_upper_1267432 = _1265920_887;
goto l1267430;
l1267430: ;
bh_upper_1267432 = pbh_upper_1267432;
union variant_220130 _1267436;
_1267436 = bh_upper_1267432.e1;
unsigned int _1267433;
_1267433 = bh_upper_1267432.e0;
bool _1267434;
_1267434 = _1267433 == 0;
if (_1267434) goto l1267435; else goto l1267554;
l1267554: ;
bool _1267555;
_1267555 = _1267433 == 1;
if (_1267555) goto l1267556; else goto l1267558;
l1267558: ;
// bottom: float r4_1265918_895;
// bottom: p_1267447 = r4_1265918_895;
goto l1267445;
l1267556: ;
float c_1267557;
c_1267557 = _1267436.pf32;
p_1267447 = c_1267557;
goto l1267445;
l1267435: ;
int y_1267437;
y_1267437 = _1267436.qs32;
int _1267438;
_1267438 = y_1267437 * _1267414;
int _1267439;
_1267439 = _1267438 + gid_x_1267417;
int _1267440;
_1267440 = 128 + _1267439;
float* idx_1267441;
idx_1267441 = _1011997_1267374 + _1267440;
_1267444 = __ldg(idx_1267441);
p_1267444 = _1267444;
l1267442: ;
_1267444 = p_1267444;
p_1267447 = _1267444;
goto l1267445;
l1267445: ;
_1267447 = p_1267447;
if (_1267404) goto l1267448; else goto l1267553;
l1267553: ;
pbh_upper_1267451 = _1267547;
goto l1267449;
l1267448: ;
union variant_220130 _1265919_897;
_1265919_897.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_899;
_1265920_899.e0 = 1;
_1265920_899.e1 = _1265919_897;
pbh_upper_1267451 = _1265920_899;
goto l1267449;
l1267449: ;
bh_upper_1267451 = pbh_upper_1267451;
unsigned int _1267452;
_1267452 = bh_upper_1267451.e0;
union variant_220130 _1267455;
_1267455 = bh_upper_1267451.e1;
bool _1267453;
_1267453 = _1267452 == 0;
if (_1267453) goto l1267454; else goto l1267548;
l1267548: ;
bool _1267549;
_1267549 = _1267452 == 1;
if (_1267549) goto l1267550; else goto l1267552;
l1267552: ;
// bottom: float r4_1265918_907;
// bottom: p_1267466 = r4_1265918_907;
goto l1267464;
l1267550: ;
float c_1267551;
c_1267551 = _1267455.pf32;
p_1267466 = c_1267551;
goto l1267464;
l1267454: ;
int y_1267456;
y_1267456 = _1267455.qs32;
int _1267457;
_1267457 = y_1267456 * _1267414;
int _1267458;
_1267458 = _1267457 + gid_x_1267417;
int _1267459;
_1267459 = 127 + _1267458;
float* idx_1267460;
idx_1267460 = _1011997_1267374 + _1267459;
_1267463 = __ldg(idx_1267460);
p_1267463 = _1267463;
l1267461: ;
_1267463 = p_1267463;
p_1267466 = _1267463;
goto l1267464;
l1267464: ;
_1267466 = p_1267466;
if (_1267404) goto l1267467; else goto l1267545;
l1267545: ;
pbh_upper_1267470 = _1267547;
goto l1267468;
l1267467: ;
union variant_220130 _1265919_909;
_1265919_909.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_911;
_1265920_911.e0 = 1;
_1265920_911.e1 = _1265919_909;
pbh_upper_1267470 = _1265920_911;
goto l1267468;
l1267468: ;
bh_upper_1267470 = pbh_upper_1267470;
unsigned int _1267471;
_1267471 = bh_upper_1267470.e0;
union variant_220130 _1267474;
_1267474 = bh_upper_1267470.e1;
bool _1267472;
_1267472 = _1267471 == 0;
if (_1267472) goto l1267473; else goto l1267540;
l1267540: ;
bool _1267541;
_1267541 = _1267471 == 1;
if (_1267541) goto l1267542; else goto l1267544;
l1267544: ;
// bottom: float r4_1265918_919;
// bottom: p_1267485 = r4_1265918_919;
goto l1267483;
l1267542: ;
float c_1267543;
c_1267543 = _1267474.pf32;
p_1267485 = c_1267543;
goto l1267483;
l1267473: ;
int y_1267475;
y_1267475 = _1267474.qs32;
int _1267476;
_1267476 = y_1267475 * _1267414;
int _1267477;
_1267477 = _1267476 + gid_x_1267417;
int _1267478;
_1267478 = 129 + _1267477;
float* idx_1267479;
idx_1267479 = _1011997_1267374 + _1267478;
_1267482 = __ldg(idx_1267479);
p_1267482 = _1267482;
l1267480: ;
_1267482 = p_1267482;
p_1267485 = _1267482;
goto l1267483;
l1267483: ;
_1267485 = p_1267485;
int _1267486;
_1267486 = 1 + gid_y_1267403;
bool _1267487;
_1267487 = _1267398 <= _1267486;
if (_1267487) goto l1267488; else goto l1267537;
l1267537: ;
union variant_220130 _1267538;
_1267538.qs32 = _1267486;
struct_BoundaryMode_220129 _1267539;
_1267539.e0 = 0;
_1267539.e1 = _1267538;
pbh_upper_1267491 = _1267539;
goto l1267489;
l1267488: ;
union variant_220130 _1265919_925;
_1265919_925.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_927;
_1265920_927.e0 = 1;
_1265920_927.e1 = _1265919_925;
pbh_upper_1267491 = _1265920_927;
goto l1267489;
l1267489: ;
bh_upper_1267491 = pbh_upper_1267491;
union variant_220130 _1267495;
_1267495 = bh_upper_1267491.e1;
unsigned int _1267492;
_1267492 = bh_upper_1267491.e0;
bool _1267493;
_1267493 = _1267492 == 0;
if (_1267493) goto l1267494; else goto l1267532;
l1267532: ;
bool _1267533;
_1267533 = _1267492 == 1;
if (_1267533) goto l1267534; else goto l1267536;
l1267536: ;
// bottom: float r4_1265918_935;
// bottom: p_1267506 = r4_1265918_935;
goto l1267504;
l1267534: ;
float c_1267535;
c_1267535 = _1267495.pf32;
p_1267506 = c_1267535;
goto l1267504;
l1267494: ;
int y_1267496;
y_1267496 = _1267495.qs32;
int _1267497;
_1267497 = y_1267496 * _1267414;
int _1267498;
_1267498 = _1267497 + gid_x_1267417;
int _1267499;
_1267499 = 128 + _1267498;
float* idx_1267500;
idx_1267500 = _1011997_1267374 + _1267499;
_1267503 = __ldg(idx_1267500);
p_1267503 = _1267503;
l1267501: ;
_1267503 = p_1267503;
p_1267506 = _1267503;
goto l1267504;
l1267504: ;
_1267506 = p_1267506;
float _1267519;
_1267519 = _1267518;
int _1267507;
_1267507 = _1011996_1267373.e3;
float _1267520;
_1267520 = 2.000000e-01f * _1267519;
float _1267526;
_1267526 = 2.500000e-01f * _1267485;
float _1267512;
_1267512 = 2.000000e-01f * _1267426;
float _1267522;
_1267522 = 2.500000e-01f * _1267447;
float _1267523;
_1267523 = 0.000000e+00f + _1267522;
float _1267521;
_1267521 = _1267512 + _1267520;
float _1267528;
_1267528 = 2.500000e-01f * _1267506;
int _1267508;
_1267508 = gid_y_1267403 * _1267507;
float _1267524;
_1267524 = 2.500000e-01f * _1267466;
float _1267525;
_1267525 = _1267523 + _1267524;
int _1267509;
_1267509 = _1267508 + gid_x_1267417;
float _1267527;
_1267527 = _1267525 + _1267526;
int _1267510;
_1267510 = 128 + _1267509;
float _1267529;
_1267529 = _1267527 + _1267528;
float* idx_1267511;
idx_1267511 = _1011995_1267372 + _1267510;
float val_1267530;
val_1267530 = _1267521 + _1267529;
*idx_1267511 = val_1267530;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1011628(struct_Img_220118 _1011631_1276201, struct_Img_220118 _1011632_1276202, float* _1011633_1276203, struct_Img_220118 _1011634_1276204, float* _1011635_1276205, float* _1011636_1276206) {
int _1276209;
int p_1276209;
int _1276212;
int p_1276212;
int _1276215;
int p_1276215;
int _1276218;
int p_1276218;
int _1276221;
int p_1276221;
int _1276224;
int p_1276224;
int _1276227;
int p_1276227;
float _1276240;
float p_1276240;
float _1276254;
float p_1276254;
float _1276259;
float p_1276259;
float _1276264;
float p_1276264;
float _1276272;
float p_1276272;
_1276209 = threadIdx_x();
p_1276209 = _1276209;
l1276207: ;
_1276209 = p_1276209;
_1276212 = blockDim_x();
p_1276212 = _1276212;
l1276210: ;
_1276212 = p_1276212;
_1276215 = blockIdx_x();
p_1276215 = _1276215;
l1276213: ;
_1276215 = p_1276215;
_1276218 = threadIdx_y();
p_1276218 = _1276218;
l1276216: ;
_1276218 = p_1276218;
_1276221 = blockDim_y();
p_1276221 = _1276221;
l1276219: ;
_1276221 = p_1276221;
_1276224 = blockIdx_y();
p_1276224 = _1276224;
l1276222: ;
_1276224 = p_1276224;
_1276227 = blockDim_y();
p_1276227 = _1276227;
l1276225: ;
_1276227 = p_1276227;
int _1276231;
_1276231 = _1011631_1276201.e3;
int _1276233;
_1276233 = _1276212 * _1276215;
int _1276228;
_1276228 = _1276221 * _1276224;
int gid_y_1276229;
gid_y_1276229 = _1276218 + _1276228;
int gid_x_1276234;
gid_x_1276234 = _1276209 + _1276233;
int _1276230;
_1276230 = 1 + gid_y_1276229;
int _1276232;
_1276232 = _1276230 * _1276231;
int _1276235;
_1276235 = _1276232 + gid_x_1276234;
int _1276236;
_1276236 = 128 + _1276235;
float* idx_1276237;
idx_1276237 = _1011635_1276205 + _1276236;
_1276240 = __ldg(idx_1276237);
p_1276240 = _1276240;
l1276238: ;
_1276240 = p_1276240;
int _1276248;
_1276248 = gid_y_1276229 * _1276231;
int _1276241;
_1276241 = _1011632_1276202.e3;
int _1276242;
_1276242 = _1276230 * _1276241;
int _1276249;
_1276249 = _1276248 + gid_x_1276234;
int _1276243;
_1276243 = _1276242 + gid_x_1276234;
int _1276250;
_1276250 = 128 + _1276249;
int _1276244;
_1276244 = 128 + _1276243;
float* idx_1276251;
idx_1276251 = _1011635_1276205 + _1276250;
float* idx_1276245;
idx_1276245 = _1011636_1276206 + _1276244;
float _1276246;
_1276246 = *idx_1276245;
_1276254 = __ldg(idx_1276251);
p_1276254 = _1276254;
l1276252: ;
_1276254 = p_1276254;
int _1276255;
_1276255 = 127 + _1276235;
float* idx_1276256;
idx_1276256 = _1011635_1276205 + _1276255;
_1276259 = __ldg(idx_1276256);
p_1276259 = _1276259;
l1276257: ;
_1276259 = p_1276259;
int _1276260;
_1276260 = 129 + _1276235;
float* idx_1276261;
idx_1276261 = _1011635_1276205 + _1276260;
_1276264 = __ldg(idx_1276261);
p_1276264 = _1276264;
l1276262: ;
_1276264 = p_1276264;
int _1276265;
_1276265 = 2 + gid_y_1276229;
int _1276266;
_1276266 = _1276265 * _1276231;
int _1276267;
_1276267 = _1276266 + gid_x_1276234;
int _1276268;
_1276268 = 128 + _1276267;
float* idx_1276269;
idx_1276269 = _1011635_1276205 + _1276268;
_1276272 = __ldg(idx_1276269);
p_1276272 = _1276272;
l1276270: ;
_1276272 = p_1276272;
float _1276284;
_1276284 = 2.500000e-01f * _1276259;
float _1276279;
_1276279 = _1276246;
float _1276280;
_1276280 = 2.000000e-01f * _1276279;
float _1276282;
_1276282 = 2.500000e-01f * _1276254;
float _1276286;
_1276286 = 2.500000e-01f * _1276264;
float _1276278;
_1276278 = 2.000000e-01f * _1276240;
float _1276288;
_1276288 = 2.500000e-01f * _1276272;
int _1276273;
_1276273 = _1011634_1276204.e3;
int _1276274;
_1276274 = _1276230 * _1276273;
float _1276281;
_1276281 = _1276278 + _1276280;
float _1276283;
_1276283 = 0.000000e+00f + _1276282;
int _1276275;
_1276275 = _1276274 + gid_x_1276234;
float _1276285;
_1276285 = _1276283 + _1276284;
int _1276276;
_1276276 = 128 + _1276275;
float _1276287;
_1276287 = _1276285 + _1276286;
float* idx_1276277;
idx_1276277 = _1011633_1276203 + _1276276;
float _1276289;
_1276289 = _1276287 + _1276288;
float val_1276290;
val_1276290 = _1276281 + _1276289;
*idx_1276277 = val_1276290;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_999837(struct_Img_220118 _999840_1282768, float* _999841_1282769, struct_Img_220118 _999842_1282770, float* _999843_1282771, float* _999844_1282772, struct_Img_220118 _999845_1282773) {
int _1282776;
int p_1282776;
int _1282779;
int p_1282779;
int _1282782;
int p_1282782;
int _1282785;
int p_1282785;
int _1282788;
int p_1282788;
int _1282791;
int p_1282791;
int _1282794;
int p_1282794;
struct_BoundaryMode_220129 bh_lower_1282801;
struct_BoundaryMode_220129 pbh_lower_1282801;
struct_BoundaryMode_220129 bh_lower_1282808;
struct_BoundaryMode_220129 pbh_lower_1282808;
float _1282825;
float p_1282825;
float _1282828;
float p_1282828;
struct_BoundaryMode_220129 bh_lower_1282832;
struct_BoundaryMode_220129 pbh_lower_1282832;
struct_BoundaryMode_220129 bh_lower_1282838;
struct_BoundaryMode_220129 pbh_lower_1282838;
float _1282854;
float p_1282854;
float _1282857;
float p_1282857;
struct_BoundaryMode_220129 bh_lower_1282863;
struct_BoundaryMode_220129 pbh_lower_1282863;
struct_BoundaryMode_220129 bh_lower_1282867;
struct_BoundaryMode_220129 pbh_lower_1282867;
float _1282883;
float p_1282883;
float _1282886;
float p_1282886;
struct_BoundaryMode_220129 bh_lower_1282892;
struct_BoundaryMode_220129 pbh_lower_1282892;
struct_BoundaryMode_220129 bh_lower_1282896;
struct_BoundaryMode_220129 pbh_lower_1282896;
float _1282912;
float p_1282912;
float _1282915;
float p_1282915;
struct_BoundaryMode_220129 bh_lower_1282919;
struct_BoundaryMode_220129 pbh_lower_1282919;
struct_BoundaryMode_220129 bh_lower_1282925;
struct_BoundaryMode_220129 pbh_lower_1282925;
float _1282941;
float p_1282941;
float _1282944;
float p_1282944;
_1282776 = threadIdx_x();
p_1282776 = _1282776;
l1282774: ;
_1282776 = p_1282776;
_1282779 = blockDim_x();
p_1282779 = _1282779;
l1282777: ;
_1282779 = p_1282779;
_1282782 = blockIdx_x();
p_1282782 = _1282782;
l1282780: ;
_1282782 = p_1282782;
_1282785 = threadIdx_y();
p_1282785 = _1282785;
l1282783: ;
_1282785 = p_1282785;
_1282788 = blockDim_y();
p_1282788 = _1282788;
l1282786: ;
_1282788 = p_1282788;
_1282791 = blockIdx_y();
p_1282791 = _1282791;
l1282789: ;
_1282791 = p_1282791;
_1282794 = blockDim_y();
p_1282794 = _1282794;
l1282792: ;
_1282794 = p_1282794;
int _1282795;
_1282795 = _1282779 * _1282782;
int gid_x_1282796;
gid_x_1282796 = _1282776 + _1282795;
union variant_220130 _1282981;
_1282981.qs32 = gid_x_1282796;
bool _1282797;
_1282797 = gid_x_1282796 < 0;
struct_BoundaryMode_220129 _1282982;
_1282982.e0 = 0;
_1282982.e1 = _1282981;
if (_1282797) goto l1282798; else goto l1283035;
l1283035: ;
pbh_lower_1282801 = _1282982;
goto l1282799;
l1282798: ;
union variant_220130 _1265919_969;
_1265919_969.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_971;
_1265920_971.e0 = 1;
_1265920_971.e1 = _1265919_969;
pbh_lower_1282801 = _1265920_971;
goto l1282799;
l1282799: ;
bh_lower_1282801 = pbh_lower_1282801;
int _1282802;
_1282802 = _1282788 * _1282791;
int gid_y_1282803;
gid_y_1282803 = _1282785 + _1282802;
union variant_220130 _1282993;
_1282993.qs32 = gid_y_1282803;
bool _1282804;
_1282804 = gid_y_1282803 < 0;
struct_BoundaryMode_220129 _1282994;
_1282994.e0 = 0;
_1282994.e1 = _1282993;
if (_1282804) goto l1282805; else goto l1283034;
l1283034: ;
pbh_lower_1282808 = _1282994;
goto l1282806;
l1282805: ;
union variant_220130 _1265919_979;
_1265919_979.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_981;
_1265920_981.e0 = 1;
_1265920_981.e1 = _1265919_979;
pbh_lower_1282808 = _1265920_981;
goto l1282806;
l1282806: ;
bh_lower_1282808 = pbh_lower_1282808;
union variant_220130 _1282819;
_1282819 = bh_lower_1282801.e1;
int _1282817;
_1282817 = _999840_1282768.e3;
unsigned int _1282809;
_1282809 = bh_lower_1282801.e0;
unsigned int _1282811;
_1282811 = bh_lower_1282808.e0;
union variant_220130 _1282815;
_1282815 = bh_lower_1282808.e1;
bool _1282810;
_1282810 = _1282809 == 0;
bool _1282812;
_1282812 = _1282811 == 0;
bool _1282813;
_1282813 = _1282810 & _1282812;
if (_1282813) goto l1282814; else goto l1283025;
l1283025: ;
bool _1283026;
_1283026 = _1282809 == 1;
if (_1283026) goto l1283027; else goto l1283029;
l1283029: ;
bool _1283030;
_1283030 = _1282811 == 1;
if (_1283030) goto l1283031; else goto l1283033;
l1283033: ;
// bottom: float r4_1265918_994;
// bottom: p_1282828 = r4_1265918_994;
goto l1282826;
l1283031: ;
float c_1283032;
c_1283032 = _1282815.pf32;
p_1282828 = c_1283032;
goto l1282826;
l1283027: ;
float c_1283028;
c_1283028 = _1282819.pf32;
p_1282828 = c_1283028;
goto l1282826;
l1282814: ;
int x_1282820;
x_1282820 = _1282819.qs32;
int y_1282816;
y_1282816 = _1282815.qs32;
int _1282818;
_1282818 = y_1282816 * _1282817;
int _1282821;
_1282821 = _1282818 + x_1282820;
float* idx_1282822;
idx_1282822 = _999841_1282769 + _1282821;
_1282825 = __ldg(idx_1282822);
p_1282825 = _1282825;
l1282823: ;
_1282825 = p_1282825;
p_1282828 = _1282825;
goto l1282826;
l1282826: ;
_1282828 = p_1282828;
int _1282950;
_1282950 = _999842_1282770.e3;
int _1282951;
_1282951 = gid_y_1282803 * _1282950;
int _1282952;
_1282952 = _1282951 + gid_x_1282796;
float* idx_1282953;
idx_1282953 = _999844_1282772 + _1282952;
float _1282954;
_1282954 = *idx_1282953;
if (_1282797) goto l1282829; else goto l1283024;
l1283024: ;
pbh_lower_1282832 = _1282982;
goto l1282830;
l1282829: ;
union variant_220130 _1265919_996;
_1265919_996.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_998;
_1265920_998.e0 = 1;
_1265920_998.e1 = _1265919_996;
pbh_lower_1282832 = _1265920_998;
goto l1282830;
l1282830: ;
bh_lower_1282832 = pbh_lower_1282832;
int _1282833;
_1282833 = -1 + gid_y_1282803;
bool _1282834;
_1282834 = _1282833 < 0;
if (_1282834) goto l1282835; else goto l1283020;
l1283020: ;
union variant_220130 _1283021;
_1283021.qs32 = _1282833;
struct_BoundaryMode_220129 _1283022;
_1283022.e0 = 0;
_1283022.e1 = _1283021;
pbh_lower_1282838 = _1283022;
goto l1282836;
l1282835: ;
union variant_220130 _1265919_1007;
_1265919_1007.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1009;
_1265920_1009.e0 = 1;
_1265920_1009.e1 = _1265919_1007;
pbh_lower_1282838 = _1265920_1009;
goto l1282836;
l1282836: ;
bh_lower_1282838 = pbh_lower_1282838;
union variant_220130 _1282848;
_1282848 = bh_lower_1282832.e1;
unsigned int _1282839;
_1282839 = bh_lower_1282832.e0;
unsigned int _1282841;
_1282841 = bh_lower_1282838.e0;
union variant_220130 _1282845;
_1282845 = bh_lower_1282838.e1;
bool _1282840;
_1282840 = _1282839 == 0;
bool _1282842;
_1282842 = _1282841 == 0;
bool _1282843;
_1282843 = _1282840 & _1282842;
if (_1282843) goto l1282844; else goto l1283011;
l1283011: ;
bool _1283012;
_1283012 = _1282839 == 1;
if (_1283012) goto l1283013; else goto l1283015;
l1283015: ;
bool _1283016;
_1283016 = _1282841 == 1;
if (_1283016) goto l1283017; else goto l1283019;
l1283019: ;
// bottom: float r4_1265918_1021;
// bottom: p_1282857 = r4_1265918_1021;
goto l1282855;
l1283017: ;
float c_1283018;
c_1283018 = _1282845.pf32;
p_1282857 = c_1283018;
goto l1282855;
l1283013: ;
float c_1283014;
c_1283014 = _1282848.pf32;
p_1282857 = c_1283014;
goto l1282855;
l1282844: ;
int x_1282849;
x_1282849 = _1282848.qs32;
int y_1282846;
y_1282846 = _1282845.qs32;
int _1282847;
_1282847 = y_1282846 * _1282817;
int _1282850;
_1282850 = _1282847 + x_1282849;
float* idx_1282851;
idx_1282851 = _999841_1282769 + _1282850;
_1282854 = __ldg(idx_1282851);
p_1282854 = _1282854;
l1282852: ;
_1282854 = p_1282854;
p_1282857 = _1282854;
goto l1282855;
l1282855: ;
_1282857 = p_1282857;
int _1282858;
_1282858 = -1 + gid_x_1282796;
bool _1282859;
_1282859 = _1282858 < 0;
if (_1282859) goto l1282860; else goto l1283008;
l1283008: ;
union variant_220130 _1283009;
_1283009.qs32 = _1282858;
struct_BoundaryMode_220129 _1283010;
_1283010.e0 = 0;
_1283010.e1 = _1283009;
pbh_lower_1282863 = _1283010;
goto l1282861;
l1282860: ;
union variant_220130 _1265919_1027;
_1265919_1027.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1029;
_1265920_1029.e0 = 1;
_1265920_1029.e1 = _1265919_1027;
pbh_lower_1282863 = _1265920_1029;
goto l1282861;
l1282861: ;
bh_lower_1282863 = pbh_lower_1282863;
if (_1282804) goto l1282864; else goto l1283007;
l1283007: ;
pbh_lower_1282867 = _1282994;
goto l1282865;
l1282864: ;
union variant_220130 _1265919_1033;
_1265919_1033.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1035;
_1265920_1035.e0 = 1;
_1265920_1035.e1 = _1265919_1033;
pbh_lower_1282867 = _1265920_1035;
goto l1282865;
l1282865: ;
bh_lower_1282867 = pbh_lower_1282867;
union variant_220130 _1282877;
_1282877 = bh_lower_1282863.e1;
union variant_220130 _1282874;
_1282874 = bh_lower_1282867.e1;
unsigned int _1282870;
_1282870 = bh_lower_1282867.e0;
unsigned int _1282868;
_1282868 = bh_lower_1282863.e0;
bool _1282871;
_1282871 = _1282870 == 0;
bool _1282869;
_1282869 = _1282868 == 0;
bool _1282872;
_1282872 = _1282869 & _1282871;
if (_1282872) goto l1282873; else goto l1282998;
l1282998: ;
bool _1282999;
_1282999 = _1282868 == 1;
if (_1282999) goto l1283000; else goto l1283002;
l1283002: ;
bool _1283003;
_1283003 = _1282870 == 1;
if (_1283003) goto l1283004; else goto l1283006;
l1283006: ;
// bottom: float r4_1265918_1047;
// bottom: p_1282886 = r4_1265918_1047;
goto l1282884;
l1283004: ;
float c_1283005;
c_1283005 = _1282874.pf32;
p_1282886 = c_1283005;
goto l1282884;
l1283000: ;
float c_1283001;
c_1283001 = _1282877.pf32;
p_1282886 = c_1283001;
goto l1282884;
l1282873: ;
int x_1282878;
x_1282878 = _1282877.qs32;
int y_1282875;
y_1282875 = _1282874.qs32;
int _1282876;
_1282876 = y_1282875 * _1282817;
int _1282879;
_1282879 = _1282876 + x_1282878;
float* idx_1282880;
idx_1282880 = _999841_1282769 + _1282879;
_1282883 = __ldg(idx_1282880);
p_1282883 = _1282883;
l1282881: ;
_1282883 = p_1282883;
p_1282886 = _1282883;
goto l1282884;
l1282884: ;
_1282886 = p_1282886;
int _1282887;
_1282887 = 1 + gid_x_1282796;
bool _1282888;
_1282888 = _1282887 < 0;
if (_1282888) goto l1282889; else goto l1282995;
l1282995: ;
union variant_220130 _1282996;
_1282996.qs32 = _1282887;
struct_BoundaryMode_220129 _1282997;
_1282997.e0 = 0;
_1282997.e1 = _1282996;
pbh_lower_1282892 = _1282997;
goto l1282890;
l1282889: ;
union variant_220130 _1265919_1053;
_1265919_1053.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1055;
_1265920_1055.e0 = 1;
_1265920_1055.e1 = _1265919_1053;
pbh_lower_1282892 = _1265920_1055;
goto l1282890;
l1282890: ;
bh_lower_1282892 = pbh_lower_1282892;
if (_1282804) goto l1282893; else goto l1282992;
l1282992: ;
pbh_lower_1282896 = _1282994;
goto l1282894;
l1282893: ;
union variant_220130 _1265919_1059;
_1265919_1059.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1061;
_1265920_1061.e0 = 1;
_1265920_1061.e1 = _1265919_1059;
pbh_lower_1282896 = _1265920_1061;
goto l1282894;
l1282894: ;
bh_lower_1282896 = pbh_lower_1282896;
union variant_220130 _1282906;
_1282906 = bh_lower_1282892.e1;
unsigned int _1282899;
_1282899 = bh_lower_1282896.e0;
unsigned int _1282897;
_1282897 = bh_lower_1282892.e0;
union variant_220130 _1282903;
_1282903 = bh_lower_1282896.e1;
bool _1282900;
_1282900 = _1282899 == 0;
bool _1282898;
_1282898 = _1282897 == 0;
bool _1282901;
_1282901 = _1282898 & _1282900;
if (_1282901) goto l1282902; else goto l1282983;
l1282983: ;
bool _1282984;
_1282984 = _1282897 == 1;
if (_1282984) goto l1282985; else goto l1282987;
l1282987: ;
bool _1282988;
_1282988 = _1282899 == 1;
if (_1282988) goto l1282989; else goto l1282991;
l1282991: ;
// bottom: float r4_1265918_1073;
// bottom: p_1282915 = r4_1265918_1073;
goto l1282913;
l1282989: ;
float c_1282990;
c_1282990 = _1282903.pf32;
p_1282915 = c_1282990;
goto l1282913;
l1282985: ;
float c_1282986;
c_1282986 = _1282906.pf32;
p_1282915 = c_1282986;
goto l1282913;
l1282902: ;
int y_1282904;
y_1282904 = _1282903.qs32;
int x_1282907;
x_1282907 = _1282906.qs32;
int _1282905;
_1282905 = y_1282904 * _1282817;
int _1282908;
_1282908 = _1282905 + x_1282907;
float* idx_1282909;
idx_1282909 = _999841_1282769 + _1282908;
_1282912 = __ldg(idx_1282909);
p_1282912 = _1282912;
l1282910: ;
_1282912 = p_1282912;
p_1282915 = _1282912;
goto l1282913;
l1282913: ;
_1282915 = p_1282915;
if (_1282797) goto l1282916; else goto l1282980;
l1282980: ;
pbh_lower_1282919 = _1282982;
goto l1282917;
l1282916: ;
union variant_220130 _1265919_1074;
_1265919_1074.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1076;
_1265920_1076.e0 = 1;
_1265920_1076.e1 = _1265919_1074;
pbh_lower_1282919 = _1265920_1076;
goto l1282917;
l1282917: ;
bh_lower_1282919 = pbh_lower_1282919;
int _1282920;
_1282920 = 1 + gid_y_1282803;
bool _1282921;
_1282921 = _1282920 < 0;
if (_1282921) goto l1282922; else goto l1282977;
l1282977: ;
union variant_220130 _1282978;
_1282978.qs32 = _1282920;
struct_BoundaryMode_220129 _1282979;
_1282979.e0 = 0;
_1282979.e1 = _1282978;
pbh_lower_1282925 = _1282979;
goto l1282923;
l1282922: ;
union variant_220130 _1265919_1085;
_1265919_1085.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1087;
_1265920_1087.e0 = 1;
_1265920_1087.e1 = _1265919_1085;
pbh_lower_1282925 = _1265920_1087;
goto l1282923;
l1282923: ;
bh_lower_1282925 = pbh_lower_1282925;
unsigned int _1282928;
_1282928 = bh_lower_1282925.e0;
union variant_220130 _1282932;
_1282932 = bh_lower_1282925.e1;
union variant_220130 _1282935;
_1282935 = bh_lower_1282919.e1;
unsigned int _1282926;
_1282926 = bh_lower_1282919.e0;
bool _1282929;
_1282929 = _1282928 == 0;
bool _1282927;
_1282927 = _1282926 == 0;
bool _1282930;
_1282930 = _1282927 & _1282929;
if (_1282930) goto l1282931; else goto l1282968;
l1282968: ;
bool _1282969;
_1282969 = _1282926 == 1;
if (_1282969) goto l1282970; else goto l1282972;
l1282972: ;
bool _1282973;
_1282973 = _1282928 == 1;
if (_1282973) goto l1282974; else goto l1282976;
l1282976: ;
// bottom: float r4_1265918_1099;
// bottom: p_1282944 = r4_1265918_1099;
goto l1282942;
l1282974: ;
float c_1282975;
c_1282975 = _1282932.pf32;
p_1282944 = c_1282975;
goto l1282942;
l1282970: ;
float c_1282971;
c_1282971 = _1282935.pf32;
p_1282944 = c_1282971;
goto l1282942;
l1282931: ;
int x_1282936;
x_1282936 = _1282935.qs32;
int y_1282933;
y_1282933 = _1282932.qs32;
int _1282934;
_1282934 = y_1282933 * _1282817;
int _1282937;
_1282937 = _1282934 + x_1282936;
float* idx_1282938;
idx_1282938 = _999841_1282769 + _1282937;
_1282941 = __ldg(idx_1282938);
p_1282941 = _1282941;
l1282939: ;
_1282941 = p_1282941;
p_1282944 = _1282941;
goto l1282942;
l1282942: ;
_1282944 = p_1282944;
float _1282964;
_1282964 = 2.500000e-01f * _1282944;
int _1282945;
_1282945 = _999845_1282773.e3;
float _1282949;
_1282949 = 2.000000e-01f * _1282828;
int _1282946;
_1282946 = gid_y_1282803 * _1282945;
float _1282960;
_1282960 = 2.500000e-01f * _1282886;
float _1282955;
_1282955 = _1282954;
float _1282962;
_1282962 = 2.500000e-01f * _1282915;
float _1282958;
_1282958 = 2.500000e-01f * _1282857;
int _1282947;
_1282947 = _1282946 + gid_x_1282796;
float _1282956;
_1282956 = 2.000000e-01f * _1282955;
float _1282959;
_1282959 = 0.000000e+00f + _1282958;
float* idx_1282948;
idx_1282948 = _999843_1282771 + _1282947;
float _1282957;
_1282957 = _1282949 + _1282956;
float _1282961;
_1282961 = _1282959 + _1282960;
float _1282963;
_1282963 = _1282961 + _1282962;
float _1282965;
_1282965 = _1282963 + _1282964;
float val_1282966;
val_1282966 = _1282957 + _1282965;
*idx_1282948 = val_1282966;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1006659(struct_Img_220118 _1006662_1274858, struct_Img_220118 _1006663_1274859, float* _1006664_1274860, struct_Img_220118 _1006665_1274861, float* _1006666_1274862, float* _1006667_1274863) {
int _1274866;
int p_1274866;
int _1274869;
int p_1274869;
int _1274872;
int p_1274872;
int _1274875;
int p_1274875;
int _1274878;
int p_1274878;
int _1274881;
int p_1274881;
int _1274884;
int p_1274884;
struct_BoundaryMode_220129 bh_upper_1274895;
struct_BoundaryMode_220129 pbh_upper_1274895;
float _1274910;
float p_1274910;
float _1274913;
float p_1274913;
struct_BoundaryMode_220129 bh_upper_1274919;
struct_BoundaryMode_220129 pbh_upper_1274919;
float _1274931;
float p_1274931;
float _1274934;
float p_1274934;
struct_BoundaryMode_220129 bh_upper_1274938;
struct_BoundaryMode_220129 pbh_upper_1274938;
float _1274950;
float p_1274950;
float _1274953;
float p_1274953;
struct_BoundaryMode_220129 bh_upper_1274957;
struct_BoundaryMode_220129 pbh_upper_1274957;
float _1274969;
float p_1274969;
float _1274972;
float p_1274972;
struct_BoundaryMode_220129 bh_upper_1274978;
struct_BoundaryMode_220129 pbh_upper_1274978;
float _1274990;
float p_1274990;
float _1274993;
float p_1274993;
_1274866 = threadIdx_x();
p_1274866 = _1274866;
l1274864: ;
_1274866 = p_1274866;
_1274869 = blockDim_x();
p_1274869 = _1274869;
l1274867: ;
_1274869 = p_1274869;
_1274872 = blockIdx_x();
p_1274872 = _1274872;
l1274870: ;
_1274872 = p_1274872;
_1274875 = threadIdx_y();
p_1274875 = _1274875;
l1274873: ;
_1274875 = p_1274875;
_1274878 = blockDim_y();
p_1274878 = _1274878;
l1274876: ;
_1274878 = p_1274878;
_1274881 = blockIdx_y();
p_1274881 = _1274881;
l1274879: ;
_1274881 = p_1274881;
_1274884 = blockDim_y();
p_1274884 = _1274884;
l1274882: ;
_1274884 = p_1274884;
int _1274886;
_1274886 = _1006662_1274858.e2;
int _1274887;
_1274887 = _1274886 - 1;
int _1274888;
_1274888 = _1274887 + _1274875;
int _1274889;
_1274889 = _1274878 * _1274881;
int _1274885;
_1274885 = _1006663_1274859.e2;
int gid_y_1274890;
gid_y_1274890 = _1274888 + _1274889;
bool _1274891;
_1274891 = _1274885 <= gid_y_1274890;
union variant_220130 _1275033;
_1275033.qs32 = gid_y_1274890;
struct_BoundaryMode_220129 _1275034;
_1275034.e0 = 0;
_1275034.e1 = _1275033;
if (_1274891) goto l1274892; else goto l1275055;
l1275055: ;
pbh_upper_1274895 = _1275034;
goto l1274893;
l1274892: ;
union variant_220130 _1265919_1114;
_1265919_1114.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1116;
_1265920_1116.e0 = 1;
_1265920_1116.e1 = _1265919_1114;
pbh_upper_1274895 = _1265920_1116;
goto l1274893;
l1274893: ;
bh_upper_1274895 = pbh_upper_1274895;
int _1274903;
_1274903 = _1274869 * _1274872;
union variant_220130 _1274899;
_1274899 = bh_upper_1274895.e1;
int _1274901;
_1274901 = _1006663_1274859.e3;
unsigned int _1274896;
_1274896 = bh_upper_1274895.e0;
int gid_x_1274904;
gid_x_1274904 = _1274866 + _1274903;
bool _1274897;
_1274897 = _1274896 == 0;
if (_1274897) goto l1274898; else goto l1275050;
l1275050: ;
bool _1275051;
_1275051 = _1274896 == 1;
if (_1275051) goto l1275052; else goto l1275054;
l1275054: ;
// bottom: float r4_1265918_1125;
// bottom: p_1274913 = r4_1265918_1125;
goto l1274911;
l1275052: ;
float c_1275053;
c_1275053 = _1274899.pf32;
p_1274913 = c_1275053;
goto l1274911;
l1274898: ;
int y_1274900;
y_1274900 = _1274899.qs32;
int _1274902;
_1274902 = y_1274900 * _1274901;
int _1274905;
_1274905 = _1274902 + gid_x_1274904;
int _1274906;
_1274906 = 128 + _1274905;
float* idx_1274907;
idx_1274907 = _1006664_1274860 + _1274906;
_1274910 = __ldg(idx_1274907);
p_1274910 = _1274910;
l1274908: ;
_1274910 = p_1274910;
p_1274913 = _1274910;
goto l1274911;
l1274911: ;
_1274913 = p_1274913;
int _1274914;
_1274914 = -1 + gid_y_1274890;
int _1275000;
_1275000 = _1006665_1274861.e3;
bool _1274915;
_1274915 = _1274885 <= _1274914;
int _1275001;
_1275001 = gid_y_1274890 * _1275000;
int _1275002;
_1275002 = _1275001 + gid_x_1274904;
int _1275003;
_1275003 = 128 + _1275002;
float* idx_1275004;
idx_1275004 = _1006667_1274863 + _1275003;
float _1275005;
_1275005 = *idx_1275004;
if (_1274915) goto l1274916; else goto l1275047;
l1275047: ;
union variant_220130 _1275048;
_1275048.qs32 = _1274914;
struct_BoundaryMode_220129 _1275049;
_1275049.e0 = 0;
_1275049.e1 = _1275048;
pbh_upper_1274919 = _1275049;
goto l1274917;
l1274916: ;
union variant_220130 _1265919_1133;
_1265919_1133.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1135;
_1265920_1135.e0 = 1;
_1265920_1135.e1 = _1265919_1133;
pbh_upper_1274919 = _1265920_1135;
goto l1274917;
l1274917: ;
bh_upper_1274919 = pbh_upper_1274919;
unsigned int _1274920;
_1274920 = bh_upper_1274919.e0;
union variant_220130 _1274923;
_1274923 = bh_upper_1274919.e1;
bool _1274921;
_1274921 = _1274920 == 0;
if (_1274921) goto l1274922; else goto l1275041;
l1275041: ;
bool _1275042;
_1275042 = _1274920 == 1;
if (_1275042) goto l1275043; else goto l1275045;
l1275045: ;
// bottom: float r4_1265918_1143;
// bottom: p_1274934 = r4_1265918_1143;
goto l1274932;
l1275043: ;
float c_1275044;
c_1275044 = _1274923.pf32;
p_1274934 = c_1275044;
goto l1274932;
l1274922: ;
int y_1274924;
y_1274924 = _1274923.qs32;
int _1274925;
_1274925 = y_1274924 * _1274901;
int _1274926;
_1274926 = _1274925 + gid_x_1274904;
int _1274927;
_1274927 = 128 + _1274926;
float* idx_1274928;
idx_1274928 = _1006664_1274860 + _1274927;
_1274931 = __ldg(idx_1274928);
p_1274931 = _1274931;
l1274929: ;
_1274931 = p_1274931;
p_1274934 = _1274931;
goto l1274932;
l1274932: ;
_1274934 = p_1274934;
if (_1274891) goto l1274935; else goto l1275040;
l1275040: ;
pbh_upper_1274938 = _1275034;
goto l1274936;
l1274935: ;
union variant_220130 _1265919_1145;
_1265919_1145.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1147;
_1265920_1147.e0 = 1;
_1265920_1147.e1 = _1265919_1145;
pbh_upper_1274938 = _1265920_1147;
goto l1274936;
l1274936: ;
bh_upper_1274938 = pbh_upper_1274938;
union variant_220130 _1274942;
_1274942 = bh_upper_1274938.e1;
unsigned int _1274939;
_1274939 = bh_upper_1274938.e0;
bool _1274940;
_1274940 = _1274939 == 0;
if (_1274940) goto l1274941; else goto l1275035;
l1275035: ;
bool _1275036;
_1275036 = _1274939 == 1;
if (_1275036) goto l1275037; else goto l1275039;
l1275039: ;
// bottom: float r4_1265918_1155;
// bottom: p_1274953 = r4_1265918_1155;
goto l1274951;
l1275037: ;
float c_1275038;
c_1275038 = _1274942.pf32;
p_1274953 = c_1275038;
goto l1274951;
l1274941: ;
int y_1274943;
y_1274943 = _1274942.qs32;
int _1274944;
_1274944 = y_1274943 * _1274901;
int _1274945;
_1274945 = _1274944 + gid_x_1274904;
int _1274946;
_1274946 = 127 + _1274945;
float* idx_1274947;
idx_1274947 = _1006664_1274860 + _1274946;
_1274950 = __ldg(idx_1274947);
p_1274950 = _1274950;
l1274948: ;
_1274950 = p_1274950;
p_1274953 = _1274950;
goto l1274951;
l1274951: ;
_1274953 = p_1274953;
if (_1274891) goto l1274954; else goto l1275032;
l1275032: ;
pbh_upper_1274957 = _1275034;
goto l1274955;
l1274954: ;
union variant_220130 _1265919_1157;
_1265919_1157.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1159;
_1265920_1159.e0 = 1;
_1265920_1159.e1 = _1265919_1157;
pbh_upper_1274957 = _1265920_1159;
goto l1274955;
l1274955: ;
bh_upper_1274957 = pbh_upper_1274957;
union variant_220130 _1274961;
_1274961 = bh_upper_1274957.e1;
unsigned int _1274958;
_1274958 = bh_upper_1274957.e0;
bool _1274959;
_1274959 = _1274958 == 0;
if (_1274959) goto l1274960; else goto l1275027;
l1275027: ;
bool _1275028;
_1275028 = _1274958 == 1;
if (_1275028) goto l1275029; else goto l1275031;
l1275031: ;
// bottom: float r4_1265918_1167;
// bottom: p_1274972 = r4_1265918_1167;
goto l1274970;
l1275029: ;
float c_1275030;
c_1275030 = _1274961.pf32;
p_1274972 = c_1275030;
goto l1274970;
l1274960: ;
int y_1274962;
y_1274962 = _1274961.qs32;
int _1274963;
_1274963 = y_1274962 * _1274901;
int _1274964;
_1274964 = _1274963 + gid_x_1274904;
int _1274965;
_1274965 = 129 + _1274964;
float* idx_1274966;
idx_1274966 = _1006664_1274860 + _1274965;
_1274969 = __ldg(idx_1274966);
p_1274969 = _1274969;
l1274967: ;
_1274969 = p_1274969;
p_1274972 = _1274969;
goto l1274970;
l1274970: ;
_1274972 = p_1274972;
int _1274973;
_1274973 = 1 + gid_y_1274890;
bool _1274974;
_1274974 = _1274885 <= _1274973;
if (_1274974) goto l1274975; else goto l1275024;
l1275024: ;
union variant_220130 _1275025;
_1275025.qs32 = _1274973;
struct_BoundaryMode_220129 _1275026;
_1275026.e0 = 0;
_1275026.e1 = _1275025;
pbh_upper_1274978 = _1275026;
goto l1274976;
l1274975: ;
union variant_220130 _1265919_1173;
_1265919_1173.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1175;
_1265920_1175.e0 = 1;
_1265920_1175.e1 = _1265919_1173;
pbh_upper_1274978 = _1265920_1175;
goto l1274976;
l1274976: ;
bh_upper_1274978 = pbh_upper_1274978;
unsigned int _1274979;
_1274979 = bh_upper_1274978.e0;
bool _1274980;
_1274980 = _1274979 == 0;
union variant_220130 _1274982;
_1274982 = bh_upper_1274978.e1;
if (_1274980) goto l1274981; else goto l1275019;
l1275019: ;
bool _1275020;
_1275020 = _1274979 == 1;
if (_1275020) goto l1275021; else goto l1275023;
l1275023: ;
// bottom: float r4_1265918_1183;
// bottom: p_1274993 = r4_1265918_1183;
goto l1274991;
l1275021: ;
float c_1275022;
c_1275022 = _1274982.pf32;
p_1274993 = c_1275022;
goto l1274991;
l1274981: ;
int y_1274983;
y_1274983 = _1274982.qs32;
int _1274984;
_1274984 = y_1274983 * _1274901;
int _1274985;
_1274985 = _1274984 + gid_x_1274904;
int _1274986;
_1274986 = 128 + _1274985;
float* idx_1274987;
idx_1274987 = _1006664_1274860 + _1274986;
_1274990 = __ldg(idx_1274987);
p_1274990 = _1274990;
l1274988: ;
_1274990 = p_1274990;
p_1274993 = _1274990;
goto l1274991;
l1274991: ;
_1274993 = p_1274993;
float _1275013;
_1275013 = 2.500000e-01f * _1274972;
float _1275011;
_1275011 = 2.500000e-01f * _1274953;
int _1274994;
_1274994 = _1006662_1274858.e3;
float _1275009;
_1275009 = 2.500000e-01f * _1274934;
float _1275015;
_1275015 = 2.500000e-01f * _1274993;
float _1274999;
_1274999 = 2.000000e-01f * _1274913;
int _1274995;
_1274995 = gid_y_1274890 * _1274994;
float _1275006;
_1275006 = _1275005;
float _1275010;
_1275010 = 0.000000e+00f + _1275009;
int _1274996;
_1274996 = _1274995 + gid_x_1274904;
float _1275007;
_1275007 = 2.000000e-01f * _1275006;
float _1275012;
_1275012 = _1275010 + _1275011;
int _1274997;
_1274997 = 128 + _1274996;
float _1275008;
_1275008 = _1274999 + _1275007;
float _1275014;
_1275014 = _1275012 + _1275013;
float* idx_1274998;
idx_1274998 = _1006666_1274862 + _1274997;
float _1275016;
_1275016 = _1275014 + _1275015;
float val_1275017;
val_1275017 = _1275008 + _1275016;
*idx_1274998 = val_1275017;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1014598(struct_Img_220118 _1014601_1269059, float* _1014602_1269060, struct_Img_220118 _1014603_1269061, float* _1014604_1269062, struct_Img_220118 _1014605_1269063, float* _1014606_1269064) {
int _1269067;
int p_1269067;
int _1269070;
int p_1269070;
int _1269073;
int p_1269073;
int _1269076;
int p_1269076;
int _1269079;
int p_1269079;
int _1269082;
int p_1269082;
int _1269085;
int p_1269085;
struct_BoundaryMode_220129 bh_lower_1269092;
struct_BoundaryMode_220129 pbh_lower_1269092;
float _1269107;
float p_1269107;
float _1269110;
float p_1269110;
struct_BoundaryMode_220129 bh_lower_1269114;
struct_BoundaryMode_220129 pbh_lower_1269114;
float _1269125;
float p_1269125;
float _1269128;
float p_1269128;
struct_BoundaryMode_220129 bh_lower_1269134;
struct_BoundaryMode_220129 pbh_lower_1269134;
float _1269144;
float p_1269144;
float _1269147;
float p_1269147;
struct_BoundaryMode_220129 bh_lower_1269153;
struct_BoundaryMode_220129 pbh_lower_1269153;
float _1269163;
float p_1269163;
float _1269166;
float p_1269166;
struct_BoundaryMode_220129 bh_lower_1269170;
struct_BoundaryMode_220129 pbh_lower_1269170;
float _1269182;
float p_1269182;
float _1269185;
float p_1269185;
_1269067 = threadIdx_x();
p_1269067 = _1269067;
l1269065: ;
_1269067 = p_1269067;
_1269070 = blockDim_x();
p_1269070 = _1269070;
l1269068: ;
_1269070 = p_1269070;
_1269073 = blockIdx_x();
p_1269073 = _1269073;
l1269071: ;
_1269073 = p_1269073;
_1269076 = threadIdx_y();
p_1269076 = _1269076;
l1269074: ;
_1269076 = p_1269076;
_1269079 = blockDim_y();
p_1269079 = _1269079;
l1269077: ;
_1269079 = p_1269079;
_1269082 = blockIdx_y();
p_1269082 = _1269082;
l1269080: ;
_1269082 = p_1269082;
_1269085 = blockDim_y();
p_1269085 = _1269085;
l1269083: ;
_1269085 = p_1269085;
int _1269086;
_1269086 = _1269070 * _1269073;
int gid_x_1269087;
gid_x_1269087 = _1269067 + _1269086;
bool _1269088;
_1269088 = gid_x_1269087 < 0;
union variant_220130 _1269215;
_1269215.qs32 = gid_x_1269087;
struct_BoundaryMode_220129 _1269216;
_1269216.e0 = 0;
_1269216.e1 = _1269215;
if (_1269088) goto l1269089; else goto l1269245;
l1269245: ;
pbh_lower_1269092 = _1269216;
goto l1269090;
l1269089: ;
union variant_220130 _1265919_1198;
_1265919_1198.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1200;
_1265920_1200.e0 = 1;
_1265920_1200.e1 = _1265919_1198;
pbh_lower_1269092 = _1265920_1200;
goto l1269090;
l1269090: ;
bh_lower_1269092 = pbh_lower_1269092;
int _1269099;
_1269099 = _1014605_1269063.e3;
union variant_220130 _1269101;
_1269101 = bh_lower_1269092.e1;
int _1269096;
_1269096 = _1269079 * _1269082;
int gid_y_1269097;
gid_y_1269097 = _1269076 + _1269096;
int _1269098;
_1269098 = 1 + gid_y_1269097;
unsigned int _1269093;
_1269093 = bh_lower_1269092.e0;
int _1269100;
_1269100 = _1269098 * _1269099;
bool _1269094;
_1269094 = _1269093 == 0;
if (_1269094) goto l1269095; else goto l1269240;
l1269240: ;
bool _1269241;
_1269241 = _1269093 == 1;
if (_1269241) goto l1269242; else goto l1269244;
l1269244: ;
// bottom: float r4_1265918_1210;
// bottom: p_1269110 = r4_1265918_1210;
goto l1269108;
l1269242: ;
float c_1269243;
c_1269243 = _1269101.pf32;
p_1269110 = c_1269243;
goto l1269108;
l1269095: ;
int x_1269102;
x_1269102 = _1269101.qs32;
int _1269103;
_1269103 = _1269100 + x_1269102;
float* idx_1269104;
idx_1269104 = _1014604_1269062 + _1269103;
_1269107 = __ldg(idx_1269104);
p_1269107 = _1269107;
l1269105: ;
_1269107 = p_1269107;
p_1269110 = _1269107;
goto l1269108;
l1269108: ;
_1269110 = p_1269110;
int _1269191;
_1269191 = _1014601_1269059.e3;
int _1269192;
_1269192 = _1269098 * _1269191;
int _1269193;
_1269193 = _1269192 + gid_x_1269087;
float* idx_1269194;
idx_1269194 = _1014606_1269064 + _1269193;
float _1269195;
_1269195 = *idx_1269194;
if (_1269088) goto l1269111; else goto l1269239;
l1269239: ;
pbh_lower_1269114 = _1269216;
goto l1269112;
l1269111: ;
union variant_220130 _1265919_1212;
_1265919_1212.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1214;
_1265920_1214.e0 = 1;
_1265920_1214.e1 = _1265919_1212;
pbh_lower_1269114 = _1265920_1214;
goto l1269112;
l1269112: ;
bh_lower_1269114 = pbh_lower_1269114;
unsigned int _1269115;
_1269115 = bh_lower_1269114.e0;
bool _1269116;
_1269116 = _1269115 == 0;
union variant_220130 _1269119;
_1269119 = bh_lower_1269114.e1;
if (_1269116) goto l1269117; else goto l1269233;
l1269233: ;
bool _1269234;
_1269234 = _1269115 == 1;
if (_1269234) goto l1269235; else goto l1269237;
l1269237: ;
// bottom: float r4_1265918_1222;
// bottom: p_1269128 = r4_1265918_1222;
goto l1269126;
l1269235: ;
float c_1269236;
c_1269236 = _1269119.pf32;
p_1269128 = c_1269236;
goto l1269126;
l1269117: ;
int _1269118;
_1269118 = gid_y_1269097 * _1269099;
int x_1269120;
x_1269120 = _1269119.qs32;
int _1269121;
_1269121 = _1269118 + x_1269120;
float* idx_1269122;
idx_1269122 = _1014604_1269062 + _1269121;
_1269125 = __ldg(idx_1269122);
p_1269125 = _1269125;
l1269123: ;
_1269125 = p_1269125;
p_1269128 = _1269125;
goto l1269126;
l1269126: ;
_1269128 = p_1269128;
int _1269129;
_1269129 = -1 + gid_x_1269087;
bool _1269130;
_1269130 = _1269129 < 0;
if (_1269130) goto l1269131; else goto l1269230;
l1269230: ;
union variant_220130 _1269231;
_1269231.qs32 = _1269129;
struct_BoundaryMode_220129 _1269232;
_1269232.e0 = 0;
_1269232.e1 = _1269231;
pbh_lower_1269134 = _1269232;
goto l1269132;
l1269131: ;
union variant_220130 _1265919_1228;
_1265919_1228.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1230;
_1265920_1230.e0 = 1;
_1265920_1230.e1 = _1265919_1228;
pbh_lower_1269134 = _1265920_1230;
goto l1269132;
l1269132: ;
bh_lower_1269134 = pbh_lower_1269134;
union variant_220130 _1269138;
_1269138 = bh_lower_1269134.e1;
unsigned int _1269135;
_1269135 = bh_lower_1269134.e0;
bool _1269136;
_1269136 = _1269135 == 0;
if (_1269136) goto l1269137; else goto l1269225;
l1269225: ;
bool _1269226;
_1269226 = _1269135 == 1;
if (_1269226) goto l1269227; else goto l1269229;
l1269229: ;
// bottom: float r4_1265918_1238;
// bottom: p_1269147 = r4_1265918_1238;
goto l1269145;
l1269227: ;
float c_1269228;
c_1269228 = _1269138.pf32;
p_1269147 = c_1269228;
goto l1269145;
l1269137: ;
int x_1269139;
x_1269139 = _1269138.qs32;
int _1269140;
_1269140 = _1269100 + x_1269139;
float* idx_1269141;
idx_1269141 = _1014604_1269062 + _1269140;
_1269144 = __ldg(idx_1269141);
p_1269144 = _1269144;
l1269142: ;
_1269144 = p_1269144;
p_1269147 = _1269144;
goto l1269145;
l1269145: ;
_1269147 = p_1269147;
int _1269148;
_1269148 = 1 + gid_x_1269087;
bool _1269149;
_1269149 = _1269148 < 0;
if (_1269149) goto l1269150; else goto l1269222;
l1269222: ;
union variant_220130 _1269223;
_1269223.qs32 = _1269148;
struct_BoundaryMode_220129 _1269224;
_1269224.e0 = 0;
_1269224.e1 = _1269223;
pbh_lower_1269153 = _1269224;
goto l1269151;
l1269150: ;
union variant_220130 _1265919_1244;
_1265919_1244.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1246;
_1265920_1246.e0 = 1;
_1265920_1246.e1 = _1265919_1244;
pbh_lower_1269153 = _1265920_1246;
goto l1269151;
l1269151: ;
bh_lower_1269153 = pbh_lower_1269153;
unsigned int _1269154;
_1269154 = bh_lower_1269153.e0;
union variant_220130 _1269157;
_1269157 = bh_lower_1269153.e1;
bool _1269155;
_1269155 = _1269154 == 0;
if (_1269155) goto l1269156; else goto l1269217;
l1269217: ;
bool _1269218;
_1269218 = _1269154 == 1;
if (_1269218) goto l1269219; else goto l1269221;
l1269221: ;
// bottom: float r4_1265918_1254;
// bottom: p_1269166 = r4_1265918_1254;
goto l1269164;
l1269219: ;
float c_1269220;
c_1269220 = _1269157.pf32;
p_1269166 = c_1269220;
goto l1269164;
l1269156: ;
int x_1269158;
x_1269158 = _1269157.qs32;
int _1269159;
_1269159 = _1269100 + x_1269158;
float* idx_1269160;
idx_1269160 = _1014604_1269062 + _1269159;
_1269163 = __ldg(idx_1269160);
p_1269163 = _1269163;
l1269161: ;
_1269163 = p_1269163;
p_1269166 = _1269163;
goto l1269164;
l1269164: ;
_1269166 = p_1269166;
if (_1269088) goto l1269167; else goto l1269214;
l1269214: ;
pbh_lower_1269170 = _1269216;
goto l1269168;
l1269167: ;
union variant_220130 _1265919_1255;
_1265919_1255.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1257;
_1265920_1257.e0 = 1;
_1265920_1257.e1 = _1265919_1255;
pbh_lower_1269170 = _1265920_1257;
goto l1269168;
l1269168: ;
bh_lower_1269170 = pbh_lower_1269170;
union variant_220130 _1269176;
_1269176 = bh_lower_1269170.e1;
unsigned int _1269171;
_1269171 = bh_lower_1269170.e0;
bool _1269172;
_1269172 = _1269171 == 0;
if (_1269172) goto l1269173; else goto l1269209;
l1269209: ;
bool _1269210;
_1269210 = _1269171 == 1;
if (_1269210) goto l1269211; else goto l1269213;
l1269213: ;
// bottom: float r4_1265918_1265;
// bottom: p_1269185 = r4_1265918_1265;
goto l1269183;
l1269211: ;
float c_1269212;
c_1269212 = _1269176.pf32;
p_1269185 = c_1269212;
goto l1269183;
l1269173: ;
int _1269174;
_1269174 = 2 + gid_y_1269097;
int x_1269177;
x_1269177 = _1269176.qs32;
int _1269175;
_1269175 = _1269174 * _1269099;
int _1269178;
_1269178 = _1269175 + x_1269177;
float* idx_1269179;
idx_1269179 = _1014604_1269062 + _1269178;
_1269182 = __ldg(idx_1269179);
p_1269182 = _1269182;
l1269180: ;
_1269182 = p_1269182;
p_1269185 = _1269182;
goto l1269183;
l1269183: ;
_1269185 = p_1269185;
float _1269196;
_1269196 = _1269195;
int _1269186;
_1269186 = _1014603_1269061.e3;
int _1269187;
_1269187 = _1269098 * _1269186;
float _1269203;
_1269203 = 2.500000e-01f * _1269166;
float _1269201;
_1269201 = 2.500000e-01f * _1269147;
float _1269199;
_1269199 = 2.500000e-01f * _1269128;
float _1269190;
_1269190 = 2.000000e-01f * _1269110;
float _1269205;
_1269205 = 2.500000e-01f * _1269185;
int _1269188;
_1269188 = _1269187 + gid_x_1269087;
float _1269197;
_1269197 = 2.000000e-01f * _1269196;
float _1269200;
_1269200 = 0.000000e+00f + _1269199;
float _1269198;
_1269198 = _1269190 + _1269197;
float* idx_1269189;
idx_1269189 = _1014602_1269060 + _1269188;
float _1269202;
_1269202 = _1269200 + _1269201;
float _1269204;
_1269204 = _1269202 + _1269203;
float _1269206;
_1269206 = _1269204 + _1269205;
float val_1269207;
val_1269207 = _1269198 + _1269206;
*idx_1269189 = val_1269207;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1043829(float* _1043832_1275528, struct_Img_220118 _1043833_1275529, struct_Img_220118 _1043834_1275530, float* _1043835_1275531, struct_Img_220118 _1043836_1275532, float* _1043837_1275533) {
int _1275536;
int p_1275536;
int _1275539;
int p_1275539;
int _1275542;
int p_1275542;
int _1275545;
int p_1275545;
int _1275548;
int p_1275548;
int _1275551;
int p_1275551;
int _1275554;
int p_1275554;
struct_BoundaryMode_220129 bh_lower_1275561;
struct_BoundaryMode_220129 pbh_lower_1275561;
float _1275576;
float p_1275576;
float _1275579;
float p_1275579;
struct_BoundaryMode_220129 bh_lower_1275585;
struct_BoundaryMode_220129 pbh_lower_1275585;
float _1275597;
float p_1275597;
float _1275600;
float p_1275600;
struct_BoundaryMode_220129 bh_lower_1275604;
struct_BoundaryMode_220129 pbh_lower_1275604;
float _1275616;
float p_1275616;
float _1275619;
float p_1275619;
struct_BoundaryMode_220129 bh_lower_1275623;
struct_BoundaryMode_220129 pbh_lower_1275623;
float _1275635;
float p_1275635;
float _1275638;
float p_1275638;
struct_BoundaryMode_220129 bh_lower_1275644;
struct_BoundaryMode_220129 pbh_lower_1275644;
float _1275656;
float p_1275656;
float _1275659;
float p_1275659;
_1275536 = threadIdx_x();
p_1275536 = _1275536;
l1275534: ;
_1275536 = p_1275536;
_1275539 = blockDim_x();
p_1275539 = _1275539;
l1275537: ;
_1275539 = p_1275539;
_1275542 = blockIdx_x();
p_1275542 = _1275542;
l1275540: ;
_1275542 = p_1275542;
_1275545 = threadIdx_y();
p_1275545 = _1275545;
l1275543: ;
_1275545 = p_1275545;
_1275548 = blockDim_y();
p_1275548 = _1275548;
l1275546: ;
_1275548 = p_1275548;
_1275551 = blockIdx_y();
p_1275551 = _1275551;
l1275549: ;
_1275551 = p_1275551;
_1275554 = blockDim_y();
p_1275554 = _1275554;
l1275552: ;
_1275554 = p_1275554;
int _1275555;
_1275555 = _1275548 * _1275551;
int gid_y_1275556;
gid_y_1275556 = _1275545 + _1275555;
union variant_220130 _1275699;
_1275699.qs32 = gid_y_1275556;
bool _1275557;
_1275557 = gid_y_1275556 < 0;
struct_BoundaryMode_220129 _1275700;
_1275700.e0 = 0;
_1275700.e1 = _1275699;
if (_1275557) goto l1275558; else goto l1275721;
l1275721: ;
pbh_lower_1275561 = _1275700;
goto l1275559;
l1275558: ;
union variant_220130 _1265919_1279;
_1265919_1279.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1281;
_1265920_1281.e0 = 1;
_1265920_1281.e1 = _1265919_1279;
pbh_lower_1275561 = _1265920_1281;
goto l1275559;
l1275559: ;
bh_lower_1275561 = pbh_lower_1275561;
unsigned int _1275562;
_1275562 = bh_lower_1275561.e0;
int _1275567;
_1275567 = _1043833_1275529.e3;
union variant_220130 _1275565;
_1275565 = bh_lower_1275561.e1;
bool _1275563;
_1275563 = _1275562 == 0;
int _1275569;
_1275569 = _1275539 * _1275542;
int gid_x_1275570;
gid_x_1275570 = _1275536 + _1275569;
if (_1275563) goto l1275564; else goto l1275716;
l1275716: ;
bool _1275717;
_1275717 = _1275562 == 1;
if (_1275717) goto l1275718; else goto l1275720;
l1275720: ;
// bottom: float r4_1265918_1290;
// bottom: p_1275579 = r4_1265918_1290;
goto l1275577;
l1275718: ;
float c_1275719;
c_1275719 = _1275565.pf32;
p_1275579 = c_1275719;
goto l1275577;
l1275564: ;
int y_1275566;
y_1275566 = _1275565.qs32;
int _1275568;
_1275568 = y_1275566 * _1275567;
int _1275571;
_1275571 = _1275568 + gid_x_1275570;
int _1275572;
_1275572 = 128 + _1275571;
float* idx_1275573;
idx_1275573 = _1043832_1275528 + _1275572;
_1275576 = __ldg(idx_1275573);
p_1275576 = _1275576;
l1275574: ;
_1275576 = p_1275576;
p_1275579 = _1275576;
goto l1275577;
l1275577: ;
_1275579 = p_1275579;
int _1275666;
_1275666 = _1043834_1275530.e3;
int _1275667;
_1275667 = gid_y_1275556 * _1275666;
int _1275580;
_1275580 = -1 + gid_y_1275556;
int _1275668;
_1275668 = _1275667 + gid_x_1275570;
bool _1275581;
_1275581 = _1275580 < 0;
int _1275669;
_1275669 = 128 + _1275668;
float* idx_1275670;
idx_1275670 = _1043837_1275533 + _1275669;
float _1275671;
_1275671 = *idx_1275670;
if (_1275581) goto l1275582; else goto l1275713;
l1275713: ;
union variant_220130 _1275714;
_1275714.qs32 = _1275580;
struct_BoundaryMode_220129 _1275715;
_1275715.e0 = 0;
_1275715.e1 = _1275714;
pbh_lower_1275585 = _1275715;
goto l1275583;
l1275582: ;
union variant_220130 _1265919_1299;
_1265919_1299.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1301;
_1265920_1301.e0 = 1;
_1265920_1301.e1 = _1265919_1299;
pbh_lower_1275585 = _1265920_1301;
goto l1275583;
l1275583: ;
bh_lower_1275585 = pbh_lower_1275585;
union variant_220130 _1275589;
_1275589 = bh_lower_1275585.e1;
unsigned int _1275586;
_1275586 = bh_lower_1275585.e0;
bool _1275587;
_1275587 = _1275586 == 0;
if (_1275587) goto l1275588; else goto l1275707;
l1275707: ;
bool _1275708;
_1275708 = _1275586 == 1;
if (_1275708) goto l1275709; else goto l1275711;
l1275711: ;
// bottom: float r4_1265918_1309;
// bottom: p_1275600 = r4_1265918_1309;
goto l1275598;
l1275709: ;
float c_1275710;
c_1275710 = _1275589.pf32;
p_1275600 = c_1275710;
goto l1275598;
l1275588: ;
int y_1275590;
y_1275590 = _1275589.qs32;
int _1275591;
_1275591 = y_1275590 * _1275567;
int _1275592;
_1275592 = _1275591 + gid_x_1275570;
int _1275593;
_1275593 = 128 + _1275592;
float* idx_1275594;
idx_1275594 = _1043832_1275528 + _1275593;
_1275597 = __ldg(idx_1275594);
p_1275597 = _1275597;
l1275595: ;
_1275597 = p_1275597;
p_1275600 = _1275597;
goto l1275598;
l1275598: ;
_1275600 = p_1275600;
if (_1275557) goto l1275601; else goto l1275706;
l1275706: ;
pbh_lower_1275604 = _1275700;
goto l1275602;
l1275601: ;
union variant_220130 _1265919_1311;
_1265919_1311.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1313;
_1265920_1313.e0 = 1;
_1265920_1313.e1 = _1265919_1311;
pbh_lower_1275604 = _1265920_1313;
goto l1275602;
l1275602: ;
bh_lower_1275604 = pbh_lower_1275604;
union variant_220130 _1275608;
_1275608 = bh_lower_1275604.e1;
unsigned int _1275605;
_1275605 = bh_lower_1275604.e0;
bool _1275606;
_1275606 = _1275605 == 0;
if (_1275606) goto l1275607; else goto l1275701;
l1275701: ;
bool _1275702;
_1275702 = _1275605 == 1;
if (_1275702) goto l1275703; else goto l1275705;
l1275705: ;
// bottom: float r4_1265918_1321;
// bottom: p_1275619 = r4_1265918_1321;
goto l1275617;
l1275703: ;
float c_1275704;
c_1275704 = _1275608.pf32;
p_1275619 = c_1275704;
goto l1275617;
l1275607: ;
int y_1275609;
y_1275609 = _1275608.qs32;
int _1275610;
_1275610 = y_1275609 * _1275567;
int _1275611;
_1275611 = _1275610 + gid_x_1275570;
int _1275612;
_1275612 = 127 + _1275611;
float* idx_1275613;
idx_1275613 = _1043832_1275528 + _1275612;
_1275616 = __ldg(idx_1275613);
p_1275616 = _1275616;
l1275614: ;
_1275616 = p_1275616;
p_1275619 = _1275616;
goto l1275617;
l1275617: ;
_1275619 = p_1275619;
if (_1275557) goto l1275620; else goto l1275698;
l1275698: ;
pbh_lower_1275623 = _1275700;
goto l1275621;
l1275620: ;
union variant_220130 _1265919_1323;
_1265919_1323.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1325;
_1265920_1325.e0 = 1;
_1265920_1325.e1 = _1265919_1323;
pbh_lower_1275623 = _1265920_1325;
goto l1275621;
l1275621: ;
bh_lower_1275623 = pbh_lower_1275623;
unsigned int _1275624;
_1275624 = bh_lower_1275623.e0;
union variant_220130 _1275627;
_1275627 = bh_lower_1275623.e1;
bool _1275625;
_1275625 = _1275624 == 0;
if (_1275625) goto l1275626; else goto l1275693;
l1275693: ;
bool _1275694;
_1275694 = _1275624 == 1;
if (_1275694) goto l1275695; else goto l1275697;
l1275697: ;
// bottom: float r4_1265918_1333;
// bottom: p_1275638 = r4_1265918_1333;
goto l1275636;
l1275695: ;
float c_1275696;
c_1275696 = _1275627.pf32;
p_1275638 = c_1275696;
goto l1275636;
l1275626: ;
int y_1275628;
y_1275628 = _1275627.qs32;
int _1275629;
_1275629 = y_1275628 * _1275567;
int _1275630;
_1275630 = _1275629 + gid_x_1275570;
int _1275631;
_1275631 = 129 + _1275630;
float* idx_1275632;
idx_1275632 = _1043832_1275528 + _1275631;
_1275635 = __ldg(idx_1275632);
p_1275635 = _1275635;
l1275633: ;
_1275635 = p_1275635;
p_1275638 = _1275635;
goto l1275636;
l1275636: ;
_1275638 = p_1275638;
int _1275639;
_1275639 = 1 + gid_y_1275556;
bool _1275640;
_1275640 = _1275639 < 0;
if (_1275640) goto l1275641; else goto l1275690;
l1275690: ;
union variant_220130 _1275691;
_1275691.qs32 = _1275639;
struct_BoundaryMode_220129 _1275692;
_1275692.e0 = 0;
_1275692.e1 = _1275691;
pbh_lower_1275644 = _1275692;
goto l1275642;
l1275641: ;
union variant_220130 _1265919_1340;
_1265919_1340.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1342;
_1265920_1342.e0 = 1;
_1265920_1342.e1 = _1265919_1340;
pbh_lower_1275644 = _1265920_1342;
goto l1275642;
l1275642: ;
bh_lower_1275644 = pbh_lower_1275644;
union variant_220130 _1275648;
_1275648 = bh_lower_1275644.e1;
unsigned int _1275645;
_1275645 = bh_lower_1275644.e0;
bool _1275646;
_1275646 = _1275645 == 0;
if (_1275646) goto l1275647; else goto l1275685;
l1275685: ;
bool _1275686;
_1275686 = _1275645 == 1;
if (_1275686) goto l1275687; else goto l1275689;
l1275689: ;
// bottom: float r4_1265918_1350;
// bottom: p_1275659 = r4_1265918_1350;
goto l1275657;
l1275687: ;
float c_1275688;
c_1275688 = _1275648.pf32;
p_1275659 = c_1275688;
goto l1275657;
l1275647: ;
int y_1275649;
y_1275649 = _1275648.qs32;
int _1275650;
_1275650 = y_1275649 * _1275567;
int _1275651;
_1275651 = _1275650 + gid_x_1275570;
int _1275652;
_1275652 = 128 + _1275651;
float* idx_1275653;
idx_1275653 = _1043832_1275528 + _1275652;
_1275656 = __ldg(idx_1275653);
p_1275656 = _1275656;
l1275654: ;
_1275656 = p_1275656;
p_1275659 = _1275656;
goto l1275657;
l1275657: ;
_1275659 = p_1275659;
float _1275679;
_1275679 = 2.500000e-01f * _1275638;
float _1275675;
_1275675 = 2.500000e-01f * _1275600;
float _1275681;
_1275681 = 2.500000e-01f * _1275659;
float _1275676;
_1275676 = 0.000000e+00f + _1275675;
float _1275677;
_1275677 = 2.500000e-01f * _1275619;
float _1275665;
_1275665 = 2.000000e-01f * _1275579;
float _1275678;
_1275678 = _1275676 + _1275677;
float _1275680;
_1275680 = _1275678 + _1275679;
int _1275660;
_1275660 = _1043836_1275532.e3;
float _1275672;
_1275672 = _1275671;
float _1275682;
_1275682 = _1275680 + _1275681;
int _1275661;
_1275661 = gid_y_1275556 * _1275660;
float _1275673;
_1275673 = 2.000000e-01f * _1275672;
int _1275662;
_1275662 = _1275661 + gid_x_1275570;
float _1275674;
_1275674 = _1275665 + _1275673;
int _1275663;
_1275663 = 128 + _1275662;
float val_1275683;
val_1275683 = _1275674 + _1275682;
float* idx_1275664;
idx_1275664 = _1043835_1275531 + _1275663;
*idx_1275664 = val_1275683;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1007129(struct_Img_220118 _1007132_1273211, struct_Img_220118 _1007133_1273212, float* _1007134_1273213, struct_Img_220118 _1007135_1273214, float* _1007136_1273215, float* _1007137_1273216) {
int _1273219;
int p_1273219;
int _1273222;
int p_1273222;
int _1273225;
int p_1273225;
int _1273228;
int p_1273228;
int _1273231;
int p_1273231;
int _1273234;
int p_1273234;
int _1273237;
int p_1273237;
struct_BoundaryMode_220129 bh_upper_1273248;
struct_BoundaryMode_220129 pbh_upper_1273248;
struct_BoundaryMode_220129 bh_lower_1273255;
struct_BoundaryMode_220129 pbh_lower_1273255;
float _1273272;
float p_1273272;
float _1273275;
float p_1273275;
struct_BoundaryMode_220129 bh_upper_1273279;
struct_BoundaryMode_220129 pbh_upper_1273279;
struct_BoundaryMode_220129 bh_lower_1273285;
struct_BoundaryMode_220129 pbh_lower_1273285;
float _1273301;
float p_1273301;
float _1273304;
float p_1273304;
struct_BoundaryMode_220129 bh_upper_1273310;
struct_BoundaryMode_220129 pbh_upper_1273310;
struct_BoundaryMode_220129 bh_lower_1273314;
struct_BoundaryMode_220129 pbh_lower_1273314;
float _1273330;
float p_1273330;
float _1273333;
float p_1273333;
struct_BoundaryMode_220129 bh_upper_1273339;
struct_BoundaryMode_220129 pbh_upper_1273339;
struct_BoundaryMode_220129 bh_lower_1273343;
struct_BoundaryMode_220129 pbh_lower_1273343;
float _1273359;
float p_1273359;
float _1273362;
float p_1273362;
struct_BoundaryMode_220129 bh_upper_1273366;
struct_BoundaryMode_220129 pbh_upper_1273366;
struct_BoundaryMode_220129 bh_lower_1273372;
struct_BoundaryMode_220129 pbh_lower_1273372;
float _1273388;
float p_1273388;
float _1273391;
float p_1273391;
_1273219 = threadIdx_x();
p_1273219 = _1273219;
l1273217: ;
_1273219 = p_1273219;
_1273222 = blockDim_x();
p_1273222 = _1273222;
l1273220: ;
_1273222 = p_1273222;
_1273225 = blockIdx_x();
p_1273225 = _1273225;
l1273223: ;
_1273225 = p_1273225;
_1273228 = threadIdx_y();
p_1273228 = _1273228;
l1273226: ;
_1273228 = p_1273228;
_1273231 = blockDim_y();
p_1273231 = _1273231;
l1273229: ;
_1273231 = p_1273231;
_1273234 = blockIdx_y();
p_1273234 = _1273234;
l1273232: ;
_1273234 = p_1273234;
_1273237 = blockDim_y();
p_1273237 = _1273237;
l1273235: ;
_1273237 = p_1273237;
int _1273238;
_1273238 = _1007133_1273212.e1;
int _1273242;
_1273242 = _1273222 * _1273225;
int _1273239;
_1273239 = _1007132_1273211.e1;
int _1273240;
_1273240 = _1273239 - 128;
int _1273241;
_1273241 = _1273240 + _1273219;
int gid_x_1273243;
gid_x_1273243 = _1273241 + _1273242;
bool _1273244;
_1273244 = _1273238 <= gid_x_1273243;
union variant_220130 _1273428;
_1273428.qs32 = gid_x_1273243;
struct_BoundaryMode_220129 _1273429;
_1273429.e0 = 0;
_1273429.e1 = _1273428;
if (_1273244) goto l1273245; else goto l1273482;
l1273482: ;
pbh_upper_1273248 = _1273429;
goto l1273246;
l1273245: ;
union variant_220130 _1265919_1367;
_1265919_1367.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1369;
_1265920_1369.e0 = 1;
_1265920_1369.e1 = _1265919_1367;
pbh_upper_1273248 = _1265920_1369;
goto l1273246;
l1273246: ;
bh_upper_1273248 = pbh_upper_1273248;
int _1273249;
_1273249 = _1273231 * _1273234;
int gid_y_1273250;
gid_y_1273250 = _1273228 + _1273249;
bool _1273251;
_1273251 = gid_y_1273250 < 0;
union variant_220130 _1273440;
_1273440.qs32 = gid_y_1273250;
struct_BoundaryMode_220129 _1273441;
_1273441.e0 = 0;
_1273441.e1 = _1273440;
if (_1273251) goto l1273252; else goto l1273481;
l1273481: ;
pbh_lower_1273255 = _1273441;
goto l1273253;
l1273252: ;
union variant_220130 _1265919_1377;
_1265919_1377.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1379;
_1265920_1379.e0 = 1;
_1265920_1379.e1 = _1265919_1377;
pbh_lower_1273255 = _1265920_1379;
goto l1273253;
l1273253: ;
bh_lower_1273255 = pbh_lower_1273255;
unsigned int _1273258;
_1273258 = bh_lower_1273255.e0;
unsigned int _1273256;
_1273256 = bh_upper_1273248.e0;
bool _1273259;
_1273259 = _1273258 == 0;
union variant_220130 _1273266;
_1273266 = bh_upper_1273248.e1;
int _1273264;
_1273264 = _1007133_1273212.e3;
bool _1273257;
_1273257 = _1273256 == 0;
bool _1273260;
_1273260 = _1273257 & _1273259;
union variant_220130 _1273262;
_1273262 = bh_lower_1273255.e1;
if (_1273260) goto l1273261; else goto l1273472;
l1273472: ;
bool _1273473;
_1273473 = _1273256 == 1;
if (_1273473) goto l1273474; else goto l1273476;
l1273476: ;
bool _1273477;
_1273477 = _1273258 == 1;
if (_1273477) goto l1273478; else goto l1273480;
l1273480: ;
// bottom: float r4_1265918_1392;
// bottom: p_1273275 = r4_1265918_1392;
goto l1273273;
l1273478: ;
float c_1273479;
c_1273479 = _1273262.pf32;
p_1273275 = c_1273479;
goto l1273273;
l1273474: ;
float c_1273475;
c_1273475 = _1273266.pf32;
p_1273275 = c_1273475;
goto l1273273;
l1273261: ;
int x_1273267;
x_1273267 = _1273266.qs32;
int y_1273263;
y_1273263 = _1273262.qs32;
int _1273265;
_1273265 = y_1273263 * _1273264;
int _1273268;
_1273268 = _1273265 + x_1273267;
float* idx_1273269;
idx_1273269 = _1007134_1273213 + _1273268;
_1273272 = __ldg(idx_1273269);
p_1273272 = _1273272;
l1273270: ;
_1273272 = p_1273272;
p_1273275 = _1273272;
goto l1273273;
l1273273: ;
_1273275 = p_1273275;
int _1273397;
_1273397 = _1007135_1273214.e3;
int _1273398;
_1273398 = gid_y_1273250 * _1273397;
int _1273399;
_1273399 = _1273398 + gid_x_1273243;
float* idx_1273400;
idx_1273400 = _1007137_1273216 + _1273399;
float _1273401;
_1273401 = *idx_1273400;
if (_1273244) goto l1273276; else goto l1273471;
l1273471: ;
pbh_upper_1273279 = _1273429;
goto l1273277;
l1273276: ;
union variant_220130 _1265919_1394;
_1265919_1394.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1396;
_1265920_1396.e0 = 1;
_1265920_1396.e1 = _1265919_1394;
pbh_upper_1273279 = _1265920_1396;
goto l1273277;
l1273277: ;
bh_upper_1273279 = pbh_upper_1273279;
int _1273280;
_1273280 = -1 + gid_y_1273250;
bool _1273281;
_1273281 = _1273280 < 0;
if (_1273281) goto l1273282; else goto l1273467;
l1273467: ;
union variant_220130 _1273468;
_1273468.qs32 = _1273280;
struct_BoundaryMode_220129 _1273469;
_1273469.e0 = 0;
_1273469.e1 = _1273468;
pbh_lower_1273285 = _1273469;
goto l1273283;
l1273282: ;
union variant_220130 _1265919_1405;
_1265919_1405.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1407;
_1265920_1407.e0 = 1;
_1265920_1407.e1 = _1265919_1405;
pbh_lower_1273285 = _1265920_1407;
goto l1273283;
l1273283: ;
bh_lower_1273285 = pbh_lower_1273285;
unsigned int _1273288;
_1273288 = bh_lower_1273285.e0;
bool _1273289;
_1273289 = _1273288 == 0;
union variant_220130 _1273295;
_1273295 = bh_upper_1273279.e1;
unsigned int _1273286;
_1273286 = bh_upper_1273279.e0;
bool _1273287;
_1273287 = _1273286 == 0;
union variant_220130 _1273292;
_1273292 = bh_lower_1273285.e1;
bool _1273290;
_1273290 = _1273287 & _1273289;
if (_1273290) goto l1273291; else goto l1273458;
l1273458: ;
bool _1273459;
_1273459 = _1273286 == 1;
if (_1273459) goto l1273460; else goto l1273462;
l1273462: ;
bool _1273463;
_1273463 = _1273288 == 1;
if (_1273463) goto l1273464; else goto l1273466;
l1273466: ;
// bottom: float r4_1265918_1419;
// bottom: p_1273304 = r4_1265918_1419;
goto l1273302;
l1273464: ;
float c_1273465;
c_1273465 = _1273292.pf32;
p_1273304 = c_1273465;
goto l1273302;
l1273460: ;
float c_1273461;
c_1273461 = _1273295.pf32;
p_1273304 = c_1273461;
goto l1273302;
l1273291: ;
int y_1273293;
y_1273293 = _1273292.qs32;
int x_1273296;
x_1273296 = _1273295.qs32;
int _1273294;
_1273294 = y_1273293 * _1273264;
int _1273297;
_1273297 = _1273294 + x_1273296;
float* idx_1273298;
idx_1273298 = _1007134_1273213 + _1273297;
_1273301 = __ldg(idx_1273298);
p_1273301 = _1273301;
l1273299: ;
_1273301 = p_1273301;
p_1273304 = _1273301;
goto l1273302;
l1273302: ;
_1273304 = p_1273304;
int _1273305;
_1273305 = -1 + gid_x_1273243;
bool _1273306;
_1273306 = _1273238 <= _1273305;
if (_1273306) goto l1273307; else goto l1273455;
l1273455: ;
union variant_220130 _1273456;
_1273456.qs32 = _1273305;
struct_BoundaryMode_220129 _1273457;
_1273457.e0 = 0;
_1273457.e1 = _1273456;
pbh_upper_1273310 = _1273457;
goto l1273308;
l1273307: ;
union variant_220130 _1265919_1424;
_1265919_1424.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1426;
_1265920_1426.e0 = 1;
_1265920_1426.e1 = _1265919_1424;
pbh_upper_1273310 = _1265920_1426;
goto l1273308;
l1273308: ;
bh_upper_1273310 = pbh_upper_1273310;
if (_1273251) goto l1273311; else goto l1273454;
l1273454: ;
pbh_lower_1273314 = _1273441;
goto l1273312;
l1273311: ;
union variant_220130 _1265919_1430;
_1265919_1430.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1432;
_1265920_1432.e0 = 1;
_1265920_1432.e1 = _1265919_1430;
pbh_lower_1273314 = _1265920_1432;
goto l1273312;
l1273312: ;
bh_lower_1273314 = pbh_lower_1273314;
unsigned int _1273317;
_1273317 = bh_lower_1273314.e0;
unsigned int _1273315;
_1273315 = bh_upper_1273310.e0;
union variant_220130 _1273321;
_1273321 = bh_lower_1273314.e1;
union variant_220130 _1273324;
_1273324 = bh_upper_1273310.e1;
bool _1273316;
_1273316 = _1273315 == 0;
bool _1273318;
_1273318 = _1273317 == 0;
bool _1273319;
_1273319 = _1273316 & _1273318;
if (_1273319) goto l1273320; else goto l1273445;
l1273445: ;
bool _1273446;
_1273446 = _1273315 == 1;
if (_1273446) goto l1273447; else goto l1273449;
l1273449: ;
bool _1273450;
_1273450 = _1273317 == 1;
if (_1273450) goto l1273451; else goto l1273453;
l1273453: ;
// bottom: float r4_1265918_1444;
// bottom: p_1273333 = r4_1265918_1444;
goto l1273331;
l1273451: ;
float c_1273452;
c_1273452 = _1273321.pf32;
p_1273333 = c_1273452;
goto l1273331;
l1273447: ;
float c_1273448;
c_1273448 = _1273324.pf32;
p_1273333 = c_1273448;
goto l1273331;
l1273320: ;
int y_1273322;
y_1273322 = _1273321.qs32;
int x_1273325;
x_1273325 = _1273324.qs32;
int _1273323;
_1273323 = y_1273322 * _1273264;
int _1273326;
_1273326 = _1273323 + x_1273325;
float* idx_1273327;
idx_1273327 = _1007134_1273213 + _1273326;
_1273330 = __ldg(idx_1273327);
p_1273330 = _1273330;
l1273328: ;
_1273330 = p_1273330;
p_1273333 = _1273330;
goto l1273331;
l1273331: ;
_1273333 = p_1273333;
int _1273334;
_1273334 = 1 + gid_x_1273243;
bool _1273335;
_1273335 = _1273238 <= _1273334;
if (_1273335) goto l1273336; else goto l1273442;
l1273442: ;
union variant_220130 _1273443;
_1273443.qs32 = _1273334;
struct_BoundaryMode_220129 _1273444;
_1273444.e0 = 0;
_1273444.e1 = _1273443;
pbh_upper_1273339 = _1273444;
goto l1273337;
l1273336: ;
union variant_220130 _1265919_1449;
_1265919_1449.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1451;
_1265920_1451.e0 = 1;
_1265920_1451.e1 = _1265919_1449;
pbh_upper_1273339 = _1265920_1451;
goto l1273337;
l1273337: ;
bh_upper_1273339 = pbh_upper_1273339;
if (_1273251) goto l1273340; else goto l1273439;
l1273439: ;
pbh_lower_1273343 = _1273441;
goto l1273341;
l1273340: ;
union variant_220130 _1265919_1455;
_1265919_1455.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1457;
_1265920_1457.e0 = 1;
_1265920_1457.e1 = _1265919_1455;
pbh_lower_1273343 = _1265920_1457;
goto l1273341;
l1273341: ;
bh_lower_1273343 = pbh_lower_1273343;
union variant_220130 _1273350;
_1273350 = bh_lower_1273343.e1;
union variant_220130 _1273353;
_1273353 = bh_upper_1273339.e1;
unsigned int _1273346;
_1273346 = bh_lower_1273343.e0;
unsigned int _1273344;
_1273344 = bh_upper_1273339.e0;
bool _1273345;
_1273345 = _1273344 == 0;
bool _1273347;
_1273347 = _1273346 == 0;
bool _1273348;
_1273348 = _1273345 & _1273347;
if (_1273348) goto l1273349; else goto l1273430;
l1273430: ;
bool _1273431;
_1273431 = _1273344 == 1;
if (_1273431) goto l1273432; else goto l1273434;
l1273434: ;
bool _1273435;
_1273435 = _1273346 == 1;
if (_1273435) goto l1273436; else goto l1273438;
l1273438: ;
// bottom: float r4_1265918_1469;
// bottom: p_1273362 = r4_1265918_1469;
goto l1273360;
l1273436: ;
float c_1273437;
c_1273437 = _1273350.pf32;
p_1273362 = c_1273437;
goto l1273360;
l1273432: ;
float c_1273433;
c_1273433 = _1273353.pf32;
p_1273362 = c_1273433;
goto l1273360;
l1273349: ;
int y_1273351;
y_1273351 = _1273350.qs32;
int x_1273354;
x_1273354 = _1273353.qs32;
int _1273352;
_1273352 = y_1273351 * _1273264;
int _1273355;
_1273355 = _1273352 + x_1273354;
float* idx_1273356;
idx_1273356 = _1007134_1273213 + _1273355;
_1273359 = __ldg(idx_1273356);
p_1273359 = _1273359;
l1273357: ;
_1273359 = p_1273359;
p_1273362 = _1273359;
goto l1273360;
l1273360: ;
_1273362 = p_1273362;
if (_1273244) goto l1273363; else goto l1273427;
l1273427: ;
pbh_upper_1273366 = _1273429;
goto l1273364;
l1273363: ;
union variant_220130 _1265919_1470;
_1265919_1470.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1472;
_1265920_1472.e0 = 1;
_1265920_1472.e1 = _1265919_1470;
pbh_upper_1273366 = _1265920_1472;
goto l1273364;
l1273364: ;
bh_upper_1273366 = pbh_upper_1273366;
int _1273367;
_1273367 = 1 + gid_y_1273250;
bool _1273368;
_1273368 = _1273367 < 0;
if (_1273368) goto l1273369; else goto l1273424;
l1273424: ;
union variant_220130 _1273425;
_1273425.qs32 = _1273367;
struct_BoundaryMode_220129 _1273426;
_1273426.e0 = 0;
_1273426.e1 = _1273425;
pbh_lower_1273372 = _1273426;
goto l1273370;
l1273369: ;
union variant_220130 _1265919_1481;
_1265919_1481.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1483;
_1265920_1483.e0 = 1;
_1265920_1483.e1 = _1265919_1481;
pbh_lower_1273372 = _1265920_1483;
goto l1273370;
l1273370: ;
bh_lower_1273372 = pbh_lower_1273372;
union variant_220130 _1273379;
_1273379 = bh_lower_1273372.e1;
union variant_220130 _1273382;
_1273382 = bh_upper_1273366.e1;
unsigned int _1273375;
_1273375 = bh_lower_1273372.e0;
unsigned int _1273373;
_1273373 = bh_upper_1273366.e0;
bool _1273376;
_1273376 = _1273375 == 0;
bool _1273374;
_1273374 = _1273373 == 0;
bool _1273377;
_1273377 = _1273374 & _1273376;
if (_1273377) goto l1273378; else goto l1273415;
l1273415: ;
bool _1273416;
_1273416 = _1273373 == 1;
if (_1273416) goto l1273417; else goto l1273419;
l1273419: ;
bool _1273420;
_1273420 = _1273375 == 1;
if (_1273420) goto l1273421; else goto l1273423;
l1273423: ;
// bottom: float r4_1265918_1495;
// bottom: p_1273391 = r4_1265918_1495;
goto l1273389;
l1273421: ;
float c_1273422;
c_1273422 = _1273379.pf32;
p_1273391 = c_1273422;
goto l1273389;
l1273417: ;
float c_1273418;
c_1273418 = _1273382.pf32;
p_1273391 = c_1273418;
goto l1273389;
l1273378: ;
int y_1273380;
y_1273380 = _1273379.qs32;
int x_1273383;
x_1273383 = _1273382.qs32;
int _1273381;
_1273381 = y_1273380 * _1273264;
int _1273384;
_1273384 = _1273381 + x_1273383;
float* idx_1273385;
idx_1273385 = _1007134_1273213 + _1273384;
_1273388 = __ldg(idx_1273385);
p_1273388 = _1273388;
l1273386: ;
_1273388 = p_1273388;
p_1273391 = _1273388;
goto l1273389;
l1273389: ;
_1273391 = p_1273391;
float _1273407;
_1273407 = 2.500000e-01f * _1273333;
float _1273405;
_1273405 = 2.500000e-01f * _1273304;
float _1273402;
_1273402 = _1273401;
float _1273396;
_1273396 = 2.000000e-01f * _1273275;
float _1273409;
_1273409 = 2.500000e-01f * _1273362;
float _1273403;
_1273403 = 2.000000e-01f * _1273402;
int _1273392;
_1273392 = _1007132_1273211.e3;
float _1273411;
_1273411 = 2.500000e-01f * _1273391;
float _1273406;
_1273406 = 0.000000e+00f + _1273405;
float _1273408;
_1273408 = _1273406 + _1273407;
float _1273404;
_1273404 = _1273396 + _1273403;
float _1273410;
_1273410 = _1273408 + _1273409;
int _1273393;
_1273393 = gid_y_1273250 * _1273392;
float _1273412;
_1273412 = _1273410 + _1273411;
float val_1273413;
val_1273413 = _1273404 + _1273412;
int _1273394;
_1273394 = _1273393 + gid_x_1273243;
float* idx_1273395;
idx_1273395 = _1007136_1273215 + _1273394;
*idx_1273395 = val_1273413;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1002689(struct_Img_220118 _1002692_1270521, float* _1002693_1270522, struct_Img_220118 _1002694_1270523, float* _1002695_1270524, float* _1002696_1270525, struct_Img_220118 _1002697_1270526) {
int _1270529;
int p_1270529;
int _1270532;
int p_1270532;
int _1270535;
int p_1270535;
int _1270538;
int p_1270538;
int _1270541;
int p_1270541;
int _1270544;
int p_1270544;
int _1270547;
int p_1270547;
struct_BoundaryMode_220129 bh_upper_1270558;
struct_BoundaryMode_220129 pbh_upper_1270558;
struct_BoundaryMode_220129 bh_lower_1270565;
struct_BoundaryMode_220129 pbh_lower_1270565;
float _1270582;
float p_1270582;
float _1270585;
float p_1270585;
struct_BoundaryMode_220129 bh_upper_1270589;
struct_BoundaryMode_220129 pbh_upper_1270589;
struct_BoundaryMode_220129 bh_lower_1270595;
struct_BoundaryMode_220129 pbh_lower_1270595;
float _1270611;
float p_1270611;
float _1270614;
float p_1270614;
struct_BoundaryMode_220129 bh_upper_1270620;
struct_BoundaryMode_220129 pbh_upper_1270620;
struct_BoundaryMode_220129 bh_lower_1270624;
struct_BoundaryMode_220129 pbh_lower_1270624;
float _1270640;
float p_1270640;
float _1270643;
float p_1270643;
struct_BoundaryMode_220129 bh_upper_1270649;
struct_BoundaryMode_220129 pbh_upper_1270649;
struct_BoundaryMode_220129 bh_lower_1270653;
struct_BoundaryMode_220129 pbh_lower_1270653;
float _1270669;
float p_1270669;
float _1270672;
float p_1270672;
struct_BoundaryMode_220129 bh_upper_1270676;
struct_BoundaryMode_220129 pbh_upper_1270676;
struct_BoundaryMode_220129 bh_lower_1270682;
struct_BoundaryMode_220129 pbh_lower_1270682;
float _1270698;
float p_1270698;
float _1270701;
float p_1270701;
_1270529 = threadIdx_x();
p_1270529 = _1270529;
l1270527: ;
_1270529 = p_1270529;
_1270532 = blockDim_x();
p_1270532 = _1270532;
l1270530: ;
_1270532 = p_1270532;
_1270535 = blockIdx_x();
p_1270535 = _1270535;
l1270533: ;
_1270535 = p_1270535;
_1270538 = threadIdx_y();
p_1270538 = _1270538;
l1270536: ;
_1270538 = p_1270538;
_1270541 = blockDim_y();
p_1270541 = _1270541;
l1270539: ;
_1270541 = p_1270541;
_1270544 = blockIdx_y();
p_1270544 = _1270544;
l1270542: ;
_1270544 = p_1270544;
_1270547 = blockDim_y();
p_1270547 = _1270547;
l1270545: ;
_1270547 = p_1270547;
int _1270549;
_1270549 = _1002697_1270526.e1;
int _1270552;
_1270552 = _1270532 * _1270535;
int _1270548;
_1270548 = _1002692_1270521.e1;
int _1270550;
_1270550 = _1270549 - 128;
int _1270551;
_1270551 = _1270550 + _1270529;
int gid_x_1270553;
gid_x_1270553 = _1270551 + _1270552;
union variant_220130 _1270738;
_1270738.qs32 = gid_x_1270553;
bool _1270554;
_1270554 = _1270548 <= gid_x_1270553;
struct_BoundaryMode_220129 _1270739;
_1270739.e0 = 0;
_1270739.e1 = _1270738;
if (_1270554) goto l1270555; else goto l1270792;
l1270792: ;
pbh_upper_1270558 = _1270739;
goto l1270556;
l1270555: ;
union variant_220130 _1265919_1510;
_1265919_1510.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1512;
_1265920_1512.e0 = 1;
_1265920_1512.e1 = _1265919_1510;
pbh_upper_1270558 = _1265920_1512;
goto l1270556;
l1270556: ;
bh_upper_1270558 = pbh_upper_1270558;
int _1270559;
_1270559 = _1270541 * _1270544;
int gid_y_1270560;
gid_y_1270560 = _1270538 + _1270559;
union variant_220130 _1270750;
_1270750.qs32 = gid_y_1270560;
bool _1270561;
_1270561 = gid_y_1270560 < 0;
struct_BoundaryMode_220129 _1270751;
_1270751.e0 = 0;
_1270751.e1 = _1270750;
if (_1270561) goto l1270562; else goto l1270791;
l1270791: ;
pbh_lower_1270565 = _1270751;
goto l1270563;
l1270562: ;
union variant_220130 _1265919_1520;
_1265919_1520.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1522;
_1265920_1522.e0 = 1;
_1265920_1522.e1 = _1265919_1520;
pbh_lower_1270565 = _1265920_1522;
goto l1270563;
l1270563: ;
bh_lower_1270565 = pbh_lower_1270565;
union variant_220130 _1270576;
_1270576 = bh_upper_1270558.e1;
unsigned int _1270566;
_1270566 = bh_upper_1270558.e0;
union variant_220130 _1270572;
_1270572 = bh_lower_1270565.e1;
unsigned int _1270568;
_1270568 = bh_lower_1270565.e0;
bool _1270567;
_1270567 = _1270566 == 0;
bool _1270569;
_1270569 = _1270568 == 0;
int _1270574;
_1270574 = _1002692_1270521.e3;
bool _1270570;
_1270570 = _1270567 & _1270569;
if (_1270570) goto l1270571; else goto l1270782;
l1270782: ;
bool _1270783;
_1270783 = _1270566 == 1;
if (_1270783) goto l1270784; else goto l1270786;
l1270786: ;
bool _1270787;
_1270787 = _1270568 == 1;
if (_1270787) goto l1270788; else goto l1270790;
l1270790: ;
// bottom: float r4_1265918_1535;
// bottom: p_1270585 = r4_1265918_1535;
goto l1270583;
l1270788: ;
float c_1270789;
c_1270789 = _1270572.pf32;
p_1270585 = c_1270789;
goto l1270583;
l1270784: ;
float c_1270785;
c_1270785 = _1270576.pf32;
p_1270585 = c_1270785;
goto l1270583;
l1270571: ;
int y_1270573;
y_1270573 = _1270572.qs32;
int x_1270577;
x_1270577 = _1270576.qs32;
int _1270575;
_1270575 = y_1270573 * _1270574;
int _1270578;
_1270578 = _1270575 + x_1270577;
float* idx_1270579;
idx_1270579 = _1002693_1270522 + _1270578;
_1270582 = __ldg(idx_1270579);
p_1270582 = _1270582;
l1270580: ;
_1270582 = p_1270582;
p_1270585 = _1270582;
goto l1270583;
l1270583: ;
_1270585 = p_1270585;
int _1270707;
_1270707 = _1002694_1270523.e3;
int _1270708;
_1270708 = gid_y_1270560 * _1270707;
int _1270709;
_1270709 = _1270708 + gid_x_1270553;
float* idx_1270710;
idx_1270710 = _1002696_1270525 + _1270709;
float _1270711;
_1270711 = *idx_1270710;
if (_1270554) goto l1270586; else goto l1270781;
l1270781: ;
pbh_upper_1270589 = _1270739;
goto l1270587;
l1270586: ;
union variant_220130 _1265919_1537;
_1265919_1537.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1539;
_1265920_1539.e0 = 1;
_1265920_1539.e1 = _1265919_1537;
pbh_upper_1270589 = _1265920_1539;
goto l1270587;
l1270587: ;
bh_upper_1270589 = pbh_upper_1270589;
int _1270590;
_1270590 = -1 + gid_y_1270560;
bool _1270591;
_1270591 = _1270590 < 0;
if (_1270591) goto l1270592; else goto l1270777;
l1270777: ;
union variant_220130 _1270778;
_1270778.qs32 = _1270590;
struct_BoundaryMode_220129 _1270779;
_1270779.e0 = 0;
_1270779.e1 = _1270778;
pbh_lower_1270595 = _1270779;
goto l1270593;
l1270592: ;
union variant_220130 _1265919_1548;
_1265919_1548.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1550;
_1265920_1550.e0 = 1;
_1265920_1550.e1 = _1265919_1548;
pbh_lower_1270595 = _1265920_1550;
goto l1270593;
l1270593: ;
bh_lower_1270595 = pbh_lower_1270595;
union variant_220130 _1270605;
_1270605 = bh_upper_1270589.e1;
unsigned int _1270598;
_1270598 = bh_lower_1270595.e0;
union variant_220130 _1270602;
_1270602 = bh_lower_1270595.e1;
bool _1270599;
_1270599 = _1270598 == 0;
unsigned int _1270596;
_1270596 = bh_upper_1270589.e0;
bool _1270597;
_1270597 = _1270596 == 0;
bool _1270600;
_1270600 = _1270597 & _1270599;
if (_1270600) goto l1270601; else goto l1270768;
l1270768: ;
bool _1270769;
_1270769 = _1270596 == 1;
if (_1270769) goto l1270770; else goto l1270772;
l1270772: ;
bool _1270773;
_1270773 = _1270598 == 1;
if (_1270773) goto l1270774; else goto l1270776;
l1270776: ;
// bottom: float r4_1265918_1562;
// bottom: p_1270614 = r4_1265918_1562;
goto l1270612;
l1270774: ;
float c_1270775;
c_1270775 = _1270602.pf32;
p_1270614 = c_1270775;
goto l1270612;
l1270770: ;
float c_1270771;
c_1270771 = _1270605.pf32;
p_1270614 = c_1270771;
goto l1270612;
l1270601: ;
int x_1270606;
x_1270606 = _1270605.qs32;
int y_1270603;
y_1270603 = _1270602.qs32;
int _1270604;
_1270604 = y_1270603 * _1270574;
int _1270607;
_1270607 = _1270604 + x_1270606;
float* idx_1270608;
idx_1270608 = _1002693_1270522 + _1270607;
_1270611 = __ldg(idx_1270608);
p_1270611 = _1270611;
l1270609: ;
_1270611 = p_1270611;
p_1270614 = _1270611;
goto l1270612;
l1270612: ;
_1270614 = p_1270614;
int _1270615;
_1270615 = -1 + gid_x_1270553;
bool _1270616;
_1270616 = _1270548 <= _1270615;
if (_1270616) goto l1270617; else goto l1270765;
l1270765: ;
union variant_220130 _1270766;
_1270766.qs32 = _1270615;
struct_BoundaryMode_220129 _1270767;
_1270767.e0 = 0;
_1270767.e1 = _1270766;
pbh_upper_1270620 = _1270767;
goto l1270618;
l1270617: ;
union variant_220130 _1265919_1567;
_1265919_1567.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1569;
_1265920_1569.e0 = 1;
_1265920_1569.e1 = _1265919_1567;
pbh_upper_1270620 = _1265920_1569;
goto l1270618;
l1270618: ;
bh_upper_1270620 = pbh_upper_1270620;
if (_1270561) goto l1270621; else goto l1270764;
l1270764: ;
pbh_lower_1270624 = _1270751;
goto l1270622;
l1270621: ;
union variant_220130 _1265919_1573;
_1265919_1573.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1575;
_1265920_1575.e0 = 1;
_1265920_1575.e1 = _1265919_1573;
pbh_lower_1270624 = _1265920_1575;
goto l1270622;
l1270622: ;
bh_lower_1270624 = pbh_lower_1270624;
union variant_220130 _1270634;
_1270634 = bh_upper_1270620.e1;
unsigned int _1270625;
_1270625 = bh_upper_1270620.e0;
unsigned int _1270627;
_1270627 = bh_lower_1270624.e0;
union variant_220130 _1270631;
_1270631 = bh_lower_1270624.e1;
bool _1270626;
_1270626 = _1270625 == 0;
bool _1270628;
_1270628 = _1270627 == 0;
bool _1270629;
_1270629 = _1270626 & _1270628;
if (_1270629) goto l1270630; else goto l1270755;
l1270755: ;
bool _1270756;
_1270756 = _1270625 == 1;
if (_1270756) goto l1270757; else goto l1270759;
l1270759: ;
bool _1270760;
_1270760 = _1270627 == 1;
if (_1270760) goto l1270761; else goto l1270763;
l1270763: ;
// bottom: float r4_1265918_1587;
// bottom: p_1270643 = r4_1265918_1587;
goto l1270641;
l1270761: ;
float c_1270762;
c_1270762 = _1270631.pf32;
p_1270643 = c_1270762;
goto l1270641;
l1270757: ;
float c_1270758;
c_1270758 = _1270634.pf32;
p_1270643 = c_1270758;
goto l1270641;
l1270630: ;
int y_1270632;
y_1270632 = _1270631.qs32;
int x_1270635;
x_1270635 = _1270634.qs32;
int _1270633;
_1270633 = y_1270632 * _1270574;
int _1270636;
_1270636 = _1270633 + x_1270635;
float* idx_1270637;
idx_1270637 = _1002693_1270522 + _1270636;
_1270640 = __ldg(idx_1270637);
p_1270640 = _1270640;
l1270638: ;
_1270640 = p_1270640;
p_1270643 = _1270640;
goto l1270641;
l1270641: ;
_1270643 = p_1270643;
int _1270644;
_1270644 = 1 + gid_x_1270553;
bool _1270645;
_1270645 = _1270548 <= _1270644;
if (_1270645) goto l1270646; else goto l1270752;
l1270752: ;
union variant_220130 _1270753;
_1270753.qs32 = _1270644;
struct_BoundaryMode_220129 _1270754;
_1270754.e0 = 0;
_1270754.e1 = _1270753;
pbh_upper_1270649 = _1270754;
goto l1270647;
l1270646: ;
union variant_220130 _1265919_1592;
_1265919_1592.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1594;
_1265920_1594.e0 = 1;
_1265920_1594.e1 = _1265919_1592;
pbh_upper_1270649 = _1265920_1594;
goto l1270647;
l1270647: ;
bh_upper_1270649 = pbh_upper_1270649;
if (_1270561) goto l1270650; else goto l1270749;
l1270749: ;
pbh_lower_1270653 = _1270751;
goto l1270651;
l1270650: ;
union variant_220130 _1265919_1598;
_1265919_1598.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1600;
_1265920_1600.e0 = 1;
_1265920_1600.e1 = _1265919_1598;
pbh_lower_1270653 = _1265920_1600;
goto l1270651;
l1270651: ;
bh_lower_1270653 = pbh_lower_1270653;
union variant_220130 _1270663;
_1270663 = bh_upper_1270649.e1;
unsigned int _1270654;
_1270654 = bh_upper_1270649.e0;
union variant_220130 _1270660;
_1270660 = bh_lower_1270653.e1;
unsigned int _1270656;
_1270656 = bh_lower_1270653.e0;
bool _1270655;
_1270655 = _1270654 == 0;
bool _1270657;
_1270657 = _1270656 == 0;
bool _1270658;
_1270658 = _1270655 & _1270657;
if (_1270658) goto l1270659; else goto l1270740;
l1270740: ;
bool _1270741;
_1270741 = _1270654 == 1;
if (_1270741) goto l1270742; else goto l1270744;
l1270744: ;
bool _1270745;
_1270745 = _1270656 == 1;
if (_1270745) goto l1270746; else goto l1270748;
l1270748: ;
// bottom: float r4_1265918_1612;
// bottom: p_1270672 = r4_1265918_1612;
goto l1270670;
l1270746: ;
float c_1270747;
c_1270747 = _1270660.pf32;
p_1270672 = c_1270747;
goto l1270670;
l1270742: ;
float c_1270743;
c_1270743 = _1270663.pf32;
p_1270672 = c_1270743;
goto l1270670;
l1270659: ;
int y_1270661;
y_1270661 = _1270660.qs32;
int x_1270664;
x_1270664 = _1270663.qs32;
int _1270662;
_1270662 = y_1270661 * _1270574;
int _1270665;
_1270665 = _1270662 + x_1270664;
float* idx_1270666;
idx_1270666 = _1002693_1270522 + _1270665;
_1270669 = __ldg(idx_1270666);
p_1270669 = _1270669;
l1270667: ;
_1270669 = p_1270669;
p_1270672 = _1270669;
goto l1270670;
l1270670: ;
_1270672 = p_1270672;
if (_1270554) goto l1270673; else goto l1270737;
l1270737: ;
pbh_upper_1270676 = _1270739;
goto l1270674;
l1270673: ;
union variant_220130 _1265919_1613;
_1265919_1613.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1615;
_1265920_1615.e0 = 1;
_1265920_1615.e1 = _1265919_1613;
pbh_upper_1270676 = _1265920_1615;
goto l1270674;
l1270674: ;
bh_upper_1270676 = pbh_upper_1270676;
int _1270677;
_1270677 = 1 + gid_y_1270560;
bool _1270678;
_1270678 = _1270677 < 0;
if (_1270678) goto l1270679; else goto l1270734;
l1270734: ;
union variant_220130 _1270735;
_1270735.qs32 = _1270677;
struct_BoundaryMode_220129 _1270736;
_1270736.e0 = 0;
_1270736.e1 = _1270735;
pbh_lower_1270682 = _1270736;
goto l1270680;
l1270679: ;
union variant_220130 _1265919_1624;
_1265919_1624.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1626;
_1265920_1626.e0 = 1;
_1265920_1626.e1 = _1265919_1624;
pbh_lower_1270682 = _1265920_1626;
goto l1270680;
l1270680: ;
bh_lower_1270682 = pbh_lower_1270682;
unsigned int _1270685;
_1270685 = bh_lower_1270682.e0;
unsigned int _1270683;
_1270683 = bh_upper_1270676.e0;
bool _1270686;
_1270686 = _1270685 == 0;
union variant_220130 _1270692;
_1270692 = bh_upper_1270676.e1;
union variant_220130 _1270689;
_1270689 = bh_lower_1270682.e1;
bool _1270684;
_1270684 = _1270683 == 0;
bool _1270687;
_1270687 = _1270684 & _1270686;
if (_1270687) goto l1270688; else goto l1270725;
l1270725: ;
bool _1270726;
_1270726 = _1270683 == 1;
if (_1270726) goto l1270727; else goto l1270729;
l1270729: ;
bool _1270730;
_1270730 = _1270685 == 1;
if (_1270730) goto l1270731; else goto l1270733;
l1270733: ;
// bottom: float r4_1265918_1638;
// bottom: p_1270701 = r4_1265918_1638;
goto l1270699;
l1270731: ;
float c_1270732;
c_1270732 = _1270689.pf32;
p_1270701 = c_1270732;
goto l1270699;
l1270727: ;
float c_1270728;
c_1270728 = _1270692.pf32;
p_1270701 = c_1270728;
goto l1270699;
l1270688: ;
int y_1270690;
y_1270690 = _1270689.qs32;
int x_1270693;
x_1270693 = _1270692.qs32;
int _1270691;
_1270691 = y_1270690 * _1270574;
int _1270694;
_1270694 = _1270691 + x_1270693;
float* idx_1270695;
idx_1270695 = _1002693_1270522 + _1270694;
_1270698 = __ldg(idx_1270695);
p_1270698 = _1270698;
l1270696: ;
_1270698 = p_1270698;
p_1270701 = _1270698;
goto l1270699;
l1270699: ;
_1270701 = p_1270701;
float _1270717;
_1270717 = 2.500000e-01f * _1270643;
float _1270706;
_1270706 = 2.000000e-01f * _1270585;
float _1270715;
_1270715 = 2.500000e-01f * _1270614;
float _1270719;
_1270719 = 2.500000e-01f * _1270672;
float _1270712;
_1270712 = _1270711;
int _1270702;
_1270702 = _1002697_1270526.e3;
float _1270721;
_1270721 = 2.500000e-01f * _1270701;
int _1270703;
_1270703 = gid_y_1270560 * _1270702;
float _1270716;
_1270716 = 0.000000e+00f + _1270715;
float _1270713;
_1270713 = 2.000000e-01f * _1270712;
int _1270704;
_1270704 = _1270703 + gid_x_1270553;
float _1270718;
_1270718 = _1270716 + _1270717;
float _1270714;
_1270714 = _1270706 + _1270713;
float* idx_1270705;
idx_1270705 = _1002695_1270524 + _1270704;
float _1270720;
_1270720 = _1270718 + _1270719;
float _1270722;
_1270722 = _1270720 + _1270721;
float val_1270723;
val_1270723 = _1270714 + _1270722;
*idx_1270705 = val_1270723;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1032459(struct_Img_220118 _1032462_1283783, float* _1032463_1283784, float* _1032464_1283785, struct_Img_220118 _1032465_1283786, struct_Img_220118 _1032466_1283787, float* _1032467_1283788) {
int _1283791;
int p_1283791;
int _1283794;
int p_1283794;
int _1283797;
int p_1283797;
int _1283800;
int p_1283800;
int _1283803;
int p_1283803;
int _1283806;
int p_1283806;
int _1283809;
int p_1283809;
struct_BoundaryMode_220129 bh_upper_1283820;
struct_BoundaryMode_220129 pbh_upper_1283820;
struct_BoundaryMode_220129 bh_upper_1283831;
struct_BoundaryMode_220129 pbh_upper_1283831;
float _1283848;
float p_1283848;
float _1283851;
float p_1283851;
struct_BoundaryMode_220129 bh_upper_1283855;
struct_BoundaryMode_220129 pbh_upper_1283855;
struct_BoundaryMode_220129 bh_upper_1283861;
struct_BoundaryMode_220129 pbh_upper_1283861;
float _1283877;
float p_1283877;
float _1283880;
float p_1283880;
struct_BoundaryMode_220129 bh_upper_1283886;
struct_BoundaryMode_220129 pbh_upper_1283886;
struct_BoundaryMode_220129 bh_upper_1283890;
struct_BoundaryMode_220129 pbh_upper_1283890;
float _1283906;
float p_1283906;
float _1283909;
float p_1283909;
struct_BoundaryMode_220129 bh_upper_1283915;
struct_BoundaryMode_220129 pbh_upper_1283915;
struct_BoundaryMode_220129 bh_upper_1283919;
struct_BoundaryMode_220129 pbh_upper_1283919;
float _1283935;
float p_1283935;
float _1283938;
float p_1283938;
struct_BoundaryMode_220129 bh_upper_1283942;
struct_BoundaryMode_220129 pbh_upper_1283942;
struct_BoundaryMode_220129 bh_upper_1283948;
struct_BoundaryMode_220129 pbh_upper_1283948;
float _1283964;
float p_1283964;
float _1283967;
float p_1283967;
_1283791 = threadIdx_x();
p_1283791 = _1283791;
l1283789: ;
_1283791 = p_1283791;
_1283794 = blockDim_x();
p_1283794 = _1283794;
l1283792: ;
_1283794 = p_1283794;
_1283797 = blockIdx_x();
p_1283797 = _1283797;
l1283795: ;
_1283797 = p_1283797;
_1283800 = threadIdx_y();
p_1283800 = _1283800;
l1283798: ;
_1283800 = p_1283800;
_1283803 = blockDim_y();
p_1283803 = _1283803;
l1283801: ;
_1283803 = p_1283803;
_1283806 = blockIdx_y();
p_1283806 = _1283806;
l1283804: ;
_1283806 = p_1283806;
_1283809 = blockDim_y();
p_1283809 = _1283809;
l1283807: ;
_1283809 = p_1283809;
int _1283810;
_1283810 = _1032465_1283786.e1;
int _1283814;
_1283814 = _1283794 * _1283797;
int _1283811;
_1283811 = _1032466_1283787.e1;
int _1283812;
_1283812 = _1283811 - 128;
int _1283813;
_1283813 = _1283812 + _1283791;
int gid_x_1283815;
gid_x_1283815 = _1283813 + _1283814;
bool _1283816;
_1283816 = _1283810 <= gid_x_1283815;
union variant_220130 _1284004;
_1284004.qs32 = gid_x_1283815;
struct_BoundaryMode_220129 _1284005;
_1284005.e0 = 0;
_1284005.e1 = _1284004;
if (_1283816) goto l1283817; else goto l1284058;
l1284058: ;
pbh_upper_1283820 = _1284005;
goto l1283818;
l1283817: ;
union variant_220130 _1265919_1653;
_1265919_1653.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1655;
_1265920_1655.e0 = 1;
_1265920_1655.e1 = _1265919_1653;
pbh_upper_1283820 = _1265920_1655;
goto l1283818;
l1283818: ;
bh_upper_1283820 = pbh_upper_1283820;
int _1283821;
_1283821 = _1032465_1283786.e2;
int _1283822;
_1283822 = _1032466_1283787.e2;
int _1283825;
_1283825 = _1283803 * _1283806;
int _1283823;
_1283823 = _1283822 - 1;
int _1283824;
_1283824 = _1283823 + _1283800;
int gid_y_1283826;
gid_y_1283826 = _1283824 + _1283825;
bool _1283827;
_1283827 = _1283821 <= gid_y_1283826;
union variant_220130 _1284016;
_1284016.qs32 = gid_y_1283826;
struct_BoundaryMode_220129 _1284017;
_1284017.e0 = 0;
_1284017.e1 = _1284016;
if (_1283827) goto l1283828; else goto l1284057;
l1284057: ;
pbh_upper_1283831 = _1284017;
goto l1283829;
l1283828: ;
union variant_220130 _1265919_1665;
_1265919_1665.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1667;
_1265920_1667.e0 = 1;
_1265920_1667.e1 = _1265919_1665;
pbh_upper_1283831 = _1265920_1667;
goto l1283829;
l1283829: ;
bh_upper_1283831 = pbh_upper_1283831;
unsigned int _1283832;
_1283832 = bh_upper_1283820.e0;
int _1283840;
_1283840 = _1032465_1283786.e3;
union variant_220130 _1283838;
_1283838 = bh_upper_1283831.e1;
unsigned int _1283834;
_1283834 = bh_upper_1283831.e0;
union variant_220130 _1283842;
_1283842 = bh_upper_1283820.e1;
bool _1283833;
_1283833 = _1283832 == 0;
bool _1283835;
_1283835 = _1283834 == 0;
bool _1283836;
_1283836 = _1283833 & _1283835;
if (_1283836) goto l1283837; else goto l1284048;
l1284048: ;
bool _1284049;
_1284049 = _1283832 == 1;
if (_1284049) goto l1284050; else goto l1284052;
l1284052: ;
bool _1284053;
_1284053 = _1283834 == 1;
if (_1284053) goto l1284054; else goto l1284056;
l1284056: ;
// bottom: float r4_1265918_1680;
// bottom: p_1283851 = r4_1265918_1680;
goto l1283849;
l1284054: ;
float c_1284055;
c_1284055 = _1283838.pf32;
p_1283851 = c_1284055;
goto l1283849;
l1284050: ;
float c_1284051;
c_1284051 = _1283842.pf32;
p_1283851 = c_1284051;
goto l1283849;
l1283837: ;
int x_1283843;
x_1283843 = _1283842.qs32;
int y_1283839;
y_1283839 = _1283838.qs32;
int _1283841;
_1283841 = y_1283839 * _1283840;
int _1283844;
_1283844 = _1283841 + x_1283843;
float* idx_1283845;
idx_1283845 = _1032464_1283785 + _1283844;
_1283848 = __ldg(idx_1283845);
p_1283848 = _1283848;
l1283846: ;
_1283848 = p_1283848;
p_1283851 = _1283848;
goto l1283849;
l1283849: ;
_1283851 = p_1283851;
int _1283973;
_1283973 = _1032462_1283783.e3;
int _1283974;
_1283974 = gid_y_1283826 * _1283973;
int _1283975;
_1283975 = _1283974 + gid_x_1283815;
float* idx_1283976;
idx_1283976 = _1032467_1283788 + _1283975;
float _1283977;
_1283977 = *idx_1283976;
if (_1283816) goto l1283852; else goto l1284047;
l1284047: ;
pbh_upper_1283855 = _1284005;
goto l1283853;
l1283852: ;
union variant_220130 _1265919_1682;
_1265919_1682.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1684;
_1265920_1684.e0 = 1;
_1265920_1684.e1 = _1265919_1682;
pbh_upper_1283855 = _1265920_1684;
goto l1283853;
l1283853: ;
bh_upper_1283855 = pbh_upper_1283855;
int _1283856;
_1283856 = -1 + gid_y_1283826;
bool _1283857;
_1283857 = _1283821 <= _1283856;
if (_1283857) goto l1283858; else goto l1284043;
l1284043: ;
union variant_220130 _1284044;
_1284044.qs32 = _1283856;
struct_BoundaryMode_220129 _1284045;
_1284045.e0 = 0;
_1284045.e1 = _1284044;
pbh_upper_1283861 = _1284045;
goto l1283859;
l1283858: ;
union variant_220130 _1265919_1692;
_1265919_1692.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1694;
_1265920_1694.e0 = 1;
_1265920_1694.e1 = _1265919_1692;
pbh_upper_1283861 = _1265920_1694;
goto l1283859;
l1283859: ;
bh_upper_1283861 = pbh_upper_1283861;
unsigned int _1283862;
_1283862 = bh_upper_1283855.e0;
union variant_220130 _1283868;
_1283868 = bh_upper_1283861.e1;
bool _1283863;
_1283863 = _1283862 == 0;
unsigned int _1283864;
_1283864 = bh_upper_1283861.e0;
union variant_220130 _1283871;
_1283871 = bh_upper_1283855.e1;
bool _1283865;
_1283865 = _1283864 == 0;
bool _1283866;
_1283866 = _1283863 & _1283865;
if (_1283866) goto l1283867; else goto l1284034;
l1284034: ;
bool _1284035;
_1284035 = _1283862 == 1;
if (_1284035) goto l1284036; else goto l1284038;
l1284038: ;
bool _1284039;
_1284039 = _1283864 == 1;
if (_1284039) goto l1284040; else goto l1284042;
l1284042: ;
// bottom: float r4_1265918_1706;
// bottom: p_1283880 = r4_1265918_1706;
goto l1283878;
l1284040: ;
float c_1284041;
c_1284041 = _1283868.pf32;
p_1283880 = c_1284041;
goto l1283878;
l1284036: ;
float c_1284037;
c_1284037 = _1283871.pf32;
p_1283880 = c_1284037;
goto l1283878;
l1283867: ;
int x_1283872;
x_1283872 = _1283871.qs32;
int y_1283869;
y_1283869 = _1283868.qs32;
int _1283870;
_1283870 = y_1283869 * _1283840;
int _1283873;
_1283873 = _1283870 + x_1283872;
float* idx_1283874;
idx_1283874 = _1032464_1283785 + _1283873;
_1283877 = __ldg(idx_1283874);
p_1283877 = _1283877;
l1283875: ;
_1283877 = p_1283877;
p_1283880 = _1283877;
goto l1283878;
l1283878: ;
_1283880 = p_1283880;
int _1283881;
_1283881 = -1 + gid_x_1283815;
bool _1283882;
_1283882 = _1283810 <= _1283881;
if (_1283882) goto l1283883; else goto l1284031;
l1284031: ;
union variant_220130 _1284032;
_1284032.qs32 = _1283881;
struct_BoundaryMode_220129 _1284033;
_1284033.e0 = 0;
_1284033.e1 = _1284032;
pbh_upper_1283886 = _1284033;
goto l1283884;
l1283883: ;
union variant_220130 _1265919_1711;
_1265919_1711.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1713;
_1265920_1713.e0 = 1;
_1265920_1713.e1 = _1265919_1711;
pbh_upper_1283886 = _1265920_1713;
goto l1283884;
l1283884: ;
bh_upper_1283886 = pbh_upper_1283886;
if (_1283827) goto l1283887; else goto l1284030;
l1284030: ;
pbh_upper_1283890 = _1284017;
goto l1283888;
l1283887: ;
union variant_220130 _1265919_1717;
_1265919_1717.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1719;
_1265920_1719.e0 = 1;
_1265920_1719.e1 = _1265919_1717;
pbh_upper_1283890 = _1265920_1719;
goto l1283888;
l1283888: ;
bh_upper_1283890 = pbh_upper_1283890;
union variant_220130 _1283897;
_1283897 = bh_upper_1283890.e1;
unsigned int _1283893;
_1283893 = bh_upper_1283890.e0;
union variant_220130 _1283900;
_1283900 = bh_upper_1283886.e1;
bool _1283894;
_1283894 = _1283893 == 0;
unsigned int _1283891;
_1283891 = bh_upper_1283886.e0;
bool _1283892;
_1283892 = _1283891 == 0;
bool _1283895;
_1283895 = _1283892 & _1283894;
if (_1283895) goto l1283896; else goto l1284021;
l1284021: ;
bool _1284022;
_1284022 = _1283891 == 1;
if (_1284022) goto l1284023; else goto l1284025;
l1284025: ;
bool _1284026;
_1284026 = _1283893 == 1;
if (_1284026) goto l1284027; else goto l1284029;
l1284029: ;
// bottom: float r4_1265918_1731;
// bottom: p_1283909 = r4_1265918_1731;
goto l1283907;
l1284027: ;
float c_1284028;
c_1284028 = _1283897.pf32;
p_1283909 = c_1284028;
goto l1283907;
l1284023: ;
float c_1284024;
c_1284024 = _1283900.pf32;
p_1283909 = c_1284024;
goto l1283907;
l1283896: ;
int y_1283898;
y_1283898 = _1283897.qs32;
int x_1283901;
x_1283901 = _1283900.qs32;
int _1283899;
_1283899 = y_1283898 * _1283840;
int _1283902;
_1283902 = _1283899 + x_1283901;
float* idx_1283903;
idx_1283903 = _1032464_1283785 + _1283902;
_1283906 = __ldg(idx_1283903);
p_1283906 = _1283906;
l1283904: ;
_1283906 = p_1283906;
p_1283909 = _1283906;
goto l1283907;
l1283907: ;
_1283909 = p_1283909;
int _1283910;
_1283910 = 1 + gid_x_1283815;
bool _1283911;
_1283911 = _1283810 <= _1283910;
if (_1283911) goto l1283912; else goto l1284018;
l1284018: ;
union variant_220130 _1284019;
_1284019.qs32 = _1283910;
struct_BoundaryMode_220129 _1284020;
_1284020.e0 = 0;
_1284020.e1 = _1284019;
pbh_upper_1283915 = _1284020;
goto l1283913;
l1283912: ;
union variant_220130 _1265919_1736;
_1265919_1736.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1738;
_1265920_1738.e0 = 1;
_1265920_1738.e1 = _1265919_1736;
pbh_upper_1283915 = _1265920_1738;
goto l1283913;
l1283913: ;
bh_upper_1283915 = pbh_upper_1283915;
if (_1283827) goto l1283916; else goto l1284015;
l1284015: ;
pbh_upper_1283919 = _1284017;
goto l1283917;
l1283916: ;
union variant_220130 _1265919_1742;
_1265919_1742.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1744;
_1265920_1744.e0 = 1;
_1265920_1744.e1 = _1265919_1742;
pbh_upper_1283919 = _1265920_1744;
goto l1283917;
l1283917: ;
bh_upper_1283919 = pbh_upper_1283919;
union variant_220130 _1283926;
_1283926 = bh_upper_1283919.e1;
unsigned int _1283922;
_1283922 = bh_upper_1283919.e0;
unsigned int _1283920;
_1283920 = bh_upper_1283915.e0;
bool _1283923;
_1283923 = _1283922 == 0;
union variant_220130 _1283929;
_1283929 = bh_upper_1283915.e1;
bool _1283921;
_1283921 = _1283920 == 0;
bool _1283924;
_1283924 = _1283921 & _1283923;
if (_1283924) goto l1283925; else goto l1284006;
l1284006: ;
bool _1284007;
_1284007 = _1283920 == 1;
if (_1284007) goto l1284008; else goto l1284010;
l1284010: ;
bool _1284011;
_1284011 = _1283922 == 1;
if (_1284011) goto l1284012; else goto l1284014;
l1284014: ;
// bottom: float r4_1265918_1756;
// bottom: p_1283938 = r4_1265918_1756;
goto l1283936;
l1284012: ;
float c_1284013;
c_1284013 = _1283926.pf32;
p_1283938 = c_1284013;
goto l1283936;
l1284008: ;
float c_1284009;
c_1284009 = _1283929.pf32;
p_1283938 = c_1284009;
goto l1283936;
l1283925: ;
int y_1283927;
y_1283927 = _1283926.qs32;
int x_1283930;
x_1283930 = _1283929.qs32;
int _1283928;
_1283928 = y_1283927 * _1283840;
int _1283931;
_1283931 = _1283928 + x_1283930;
float* idx_1283932;
idx_1283932 = _1032464_1283785 + _1283931;
_1283935 = __ldg(idx_1283932);
p_1283935 = _1283935;
l1283933: ;
_1283935 = p_1283935;
p_1283938 = _1283935;
goto l1283936;
l1283936: ;
_1283938 = p_1283938;
if (_1283816) goto l1283939; else goto l1284003;
l1284003: ;
pbh_upper_1283942 = _1284005;
goto l1283940;
l1283939: ;
union variant_220130 _1265919_1757;
_1265919_1757.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1759;
_1265920_1759.e0 = 1;
_1265920_1759.e1 = _1265919_1757;
pbh_upper_1283942 = _1265920_1759;
goto l1283940;
l1283940: ;
bh_upper_1283942 = pbh_upper_1283942;
int _1283943;
_1283943 = 1 + gid_y_1283826;
bool _1283944;
_1283944 = _1283821 <= _1283943;
if (_1283944) goto l1283945; else goto l1284000;
l1284000: ;
union variant_220130 _1284001;
_1284001.qs32 = _1283943;
struct_BoundaryMode_220129 _1284002;
_1284002.e0 = 0;
_1284002.e1 = _1284001;
pbh_upper_1283948 = _1284002;
goto l1283946;
l1283945: ;
union variant_220130 _1265919_1767;
_1265919_1767.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1769;
_1265920_1769.e0 = 1;
_1265920_1769.e1 = _1265919_1767;
pbh_upper_1283948 = _1265920_1769;
goto l1283946;
l1283946: ;
bh_upper_1283948 = pbh_upper_1283948;
unsigned int _1283949;
_1283949 = bh_upper_1283942.e0;
unsigned int _1283951;
_1283951 = bh_upper_1283948.e0;
bool _1283952;
_1283952 = _1283951 == 0;
bool _1283950;
_1283950 = _1283949 == 0;
bool _1283953;
_1283953 = _1283950 & _1283952;
union variant_220130 _1283958;
_1283958 = bh_upper_1283942.e1;
union variant_220130 _1283955;
_1283955 = bh_upper_1283948.e1;
if (_1283953) goto l1283954; else goto l1283991;
l1283991: ;
bool _1283992;
_1283992 = _1283949 == 1;
if (_1283992) goto l1283993; else goto l1283995;
l1283995: ;
bool _1283996;
_1283996 = _1283951 == 1;
if (_1283996) goto l1283997; else goto l1283999;
l1283999: ;
// bottom: float r4_1265918_1781;
// bottom: p_1283967 = r4_1265918_1781;
goto l1283965;
l1283997: ;
float c_1283998;
c_1283998 = _1283955.pf32;
p_1283967 = c_1283998;
goto l1283965;
l1283993: ;
float c_1283994;
c_1283994 = _1283958.pf32;
p_1283967 = c_1283994;
goto l1283965;
l1283954: ;
int y_1283956;
y_1283956 = _1283955.qs32;
int _1283957;
_1283957 = y_1283956 * _1283840;
int x_1283959;
x_1283959 = _1283958.qs32;
int _1283960;
_1283960 = _1283957 + x_1283959;
float* idx_1283961;
idx_1283961 = _1032464_1283785 + _1283960;
_1283964 = __ldg(idx_1283961);
p_1283964 = _1283964;
l1283962: ;
_1283964 = p_1283964;
p_1283967 = _1283964;
goto l1283965;
l1283965: ;
_1283967 = p_1283967;
float _1283987;
_1283987 = 2.500000e-01f * _1283967;
float _1283985;
_1283985 = 2.500000e-01f * _1283938;
float _1283978;
_1283978 = _1283977;
int _1283968;
_1283968 = _1032466_1283787.e3;
float _1283972;
_1283972 = 2.000000e-01f * _1283851;
float _1283979;
_1283979 = 2.000000e-01f * _1283978;
float _1283980;
_1283980 = _1283972 + _1283979;
float _1283981;
_1283981 = 2.500000e-01f * _1283880;
float _1283983;
_1283983 = 2.500000e-01f * _1283909;
int _1283969;
_1283969 = gid_y_1283826 * _1283968;
float _1283982;
_1283982 = 0.000000e+00f + _1283981;
float _1283984;
_1283984 = _1283982 + _1283983;
int _1283970;
_1283970 = _1283969 + gid_x_1283815;
float _1283986;
_1283986 = _1283984 + _1283985;
float* idx_1283971;
idx_1283971 = _1032463_1283784 + _1283970;
float _1283988;
_1283988 = _1283986 + _1283987;
float val_1283989;
val_1283989 = _1283980 + _1283988;
*idx_1283971 = val_1283989;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1043283(float* _1043286_1275059, struct_Img_220118 _1043287_1275060, struct_Img_220118 _1043288_1275061, float* _1043289_1275062, struct_Img_220118 _1043290_1275063, float* _1043291_1275064) {
int _1275067;
int p_1275067;
int _1275070;
int p_1275070;
int _1275073;
int p_1275073;
int _1275076;
int p_1275076;
int _1275079;
int p_1275079;
int _1275082;
int p_1275082;
int _1275085;
int p_1275085;
struct_BoundaryMode_220129 bh_lower_1275092;
struct_BoundaryMode_220129 pbh_lower_1275092;
struct_BoundaryMode_220129 bh_upper_1275103;
struct_BoundaryMode_220129 pbh_upper_1275103;
float _1275120;
float p_1275120;
float _1275123;
float p_1275123;
struct_BoundaryMode_220129 bh_lower_1275127;
struct_BoundaryMode_220129 pbh_lower_1275127;
struct_BoundaryMode_220129 bh_upper_1275133;
struct_BoundaryMode_220129 pbh_upper_1275133;
float _1275149;
float p_1275149;
float _1275152;
float p_1275152;
struct_BoundaryMode_220129 bh_lower_1275158;
struct_BoundaryMode_220129 pbh_lower_1275158;
struct_BoundaryMode_220129 bh_upper_1275162;
struct_BoundaryMode_220129 pbh_upper_1275162;
float _1275178;
float p_1275178;
float _1275181;
float p_1275181;
struct_BoundaryMode_220129 bh_lower_1275187;
struct_BoundaryMode_220129 pbh_lower_1275187;
struct_BoundaryMode_220129 bh_upper_1275191;
struct_BoundaryMode_220129 pbh_upper_1275191;
float _1275207;
float p_1275207;
float _1275210;
float p_1275210;
struct_BoundaryMode_220129 bh_lower_1275214;
struct_BoundaryMode_220129 pbh_lower_1275214;
struct_BoundaryMode_220129 bh_upper_1275220;
struct_BoundaryMode_220129 pbh_upper_1275220;
float _1275236;
float p_1275236;
float _1275239;
float p_1275239;
_1275067 = threadIdx_x();
p_1275067 = _1275067;
l1275065: ;
_1275067 = p_1275067;
_1275070 = blockDim_x();
p_1275070 = _1275070;
l1275068: ;
_1275070 = p_1275070;
_1275073 = blockIdx_x();
p_1275073 = _1275073;
l1275071: ;
_1275073 = p_1275073;
_1275076 = threadIdx_y();
p_1275076 = _1275076;
l1275074: ;
_1275076 = p_1275076;
_1275079 = blockDim_y();
p_1275079 = _1275079;
l1275077: ;
_1275079 = p_1275079;
_1275082 = blockIdx_y();
p_1275082 = _1275082;
l1275080: ;
_1275082 = p_1275082;
_1275085 = blockDim_y();
p_1275085 = _1275085;
l1275083: ;
_1275085 = p_1275085;
int _1275086;
_1275086 = _1275070 * _1275073;
int gid_x_1275087;
gid_x_1275087 = _1275067 + _1275086;
bool _1275088;
_1275088 = gid_x_1275087 < 0;
union variant_220130 _1275276;
_1275276.qs32 = gid_x_1275087;
struct_BoundaryMode_220129 _1275277;
_1275277.e0 = 0;
_1275277.e1 = _1275276;
if (_1275088) goto l1275089; else goto l1275330;
l1275330: ;
pbh_lower_1275092 = _1275277;
goto l1275090;
l1275089: ;
union variant_220130 _1265919_1794;
_1265919_1794.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1796;
_1265920_1796.e0 = 1;
_1265920_1796.e1 = _1265919_1794;
pbh_lower_1275092 = _1265920_1796;
goto l1275090;
l1275090: ;
bh_lower_1275092 = pbh_lower_1275092;
int _1275097;
_1275097 = _1275079 * _1275082;
int _1275094;
_1275094 = _1043290_1275063.e2;
int _1275093;
_1275093 = _1043287_1275060.e2;
int _1275095;
_1275095 = _1275094 - 1;
int _1275096;
_1275096 = _1275095 + _1275076;
int gid_y_1275098;
gid_y_1275098 = _1275096 + _1275097;
bool _1275099;
_1275099 = _1275093 <= gid_y_1275098;
union variant_220130 _1275288;
_1275288.qs32 = gid_y_1275098;
struct_BoundaryMode_220129 _1275289;
_1275289.e0 = 0;
_1275289.e1 = _1275288;
if (_1275099) goto l1275100; else goto l1275329;
l1275329: ;
pbh_upper_1275103 = _1275289;
goto l1275101;
l1275100: ;
union variant_220130 _1265919_1806;
_1265919_1806.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1808;
_1265920_1808.e0 = 1;
_1265920_1808.e1 = _1265919_1806;
pbh_upper_1275103 = _1265920_1808;
goto l1275101;
l1275101: ;
bh_upper_1275103 = pbh_upper_1275103;
unsigned int _1275104;
_1275104 = bh_lower_1275092.e0;
bool _1275105;
_1275105 = _1275104 == 0;
unsigned int _1275106;
_1275106 = bh_upper_1275103.e0;
int _1275112;
_1275112 = _1043287_1275060.e3;
union variant_220130 _1275114;
_1275114 = bh_lower_1275092.e1;
bool _1275107;
_1275107 = _1275106 == 0;
bool _1275108;
_1275108 = _1275105 & _1275107;
union variant_220130 _1275110;
_1275110 = bh_upper_1275103.e1;
if (_1275108) goto l1275109; else goto l1275320;
l1275320: ;
bool _1275321;
_1275321 = _1275104 == 1;
if (_1275321) goto l1275322; else goto l1275324;
l1275324: ;
bool _1275325;
_1275325 = _1275106 == 1;
if (_1275325) goto l1275326; else goto l1275328;
l1275328: ;
// bottom: float r4_1265918_1821;
// bottom: p_1275123 = r4_1265918_1821;
goto l1275121;
l1275326: ;
float c_1275327;
c_1275327 = _1275110.pf32;
p_1275123 = c_1275327;
goto l1275121;
l1275322: ;
float c_1275323;
c_1275323 = _1275114.pf32;
p_1275123 = c_1275323;
goto l1275121;
l1275109: ;
int y_1275111;
y_1275111 = _1275110.qs32;
int _1275113;
_1275113 = y_1275111 * _1275112;
int x_1275115;
x_1275115 = _1275114.qs32;
int _1275116;
_1275116 = _1275113 + x_1275115;
float* idx_1275117;
idx_1275117 = _1043286_1275059 + _1275116;
_1275120 = __ldg(idx_1275117);
p_1275120 = _1275120;
l1275118: ;
_1275120 = p_1275120;
p_1275123 = _1275120;
goto l1275121;
l1275121: ;
_1275123 = p_1275123;
int _1275245;
_1275245 = _1043288_1275061.e3;
int _1275246;
_1275246 = gid_y_1275098 * _1275245;
int _1275247;
_1275247 = _1275246 + gid_x_1275087;
float* idx_1275248;
idx_1275248 = _1043291_1275064 + _1275247;
float _1275249;
_1275249 = *idx_1275248;
if (_1275088) goto l1275124; else goto l1275319;
l1275319: ;
pbh_lower_1275127 = _1275277;
goto l1275125;
l1275124: ;
union variant_220130 _1265919_1823;
_1265919_1823.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1825;
_1265920_1825.e0 = 1;
_1265920_1825.e1 = _1265919_1823;
pbh_lower_1275127 = _1265920_1825;
goto l1275125;
l1275125: ;
bh_lower_1275127 = pbh_lower_1275127;
int _1275128;
_1275128 = -1 + gid_y_1275098;
bool _1275129;
_1275129 = _1275093 <= _1275128;
if (_1275129) goto l1275130; else goto l1275315;
l1275315: ;
union variant_220130 _1275316;
_1275316.qs32 = _1275128;
struct_BoundaryMode_220129 _1275317;
_1275317.e0 = 0;
_1275317.e1 = _1275316;
pbh_upper_1275133 = _1275317;
goto l1275131;
l1275130: ;
union variant_220130 _1265919_1833;
_1265919_1833.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1835;
_1265920_1835.e0 = 1;
_1265920_1835.e1 = _1265919_1833;
pbh_upper_1275133 = _1265920_1835;
goto l1275131;
l1275131: ;
bh_upper_1275133 = pbh_upper_1275133;
union variant_220130 _1275143;
_1275143 = bh_lower_1275127.e1;
unsigned int _1275134;
_1275134 = bh_lower_1275127.e0;
union variant_220130 _1275140;
_1275140 = bh_upper_1275133.e1;
unsigned int _1275136;
_1275136 = bh_upper_1275133.e0;
bool _1275135;
_1275135 = _1275134 == 0;
bool _1275137;
_1275137 = _1275136 == 0;
bool _1275138;
_1275138 = _1275135 & _1275137;
if (_1275138) goto l1275139; else goto l1275306;
l1275306: ;
bool _1275307;
_1275307 = _1275134 == 1;
if (_1275307) goto l1275308; else goto l1275310;
l1275310: ;
bool _1275311;
_1275311 = _1275136 == 1;
if (_1275311) goto l1275312; else goto l1275314;
l1275314: ;
// bottom: float r4_1265918_1847;
// bottom: p_1275152 = r4_1265918_1847;
goto l1275150;
l1275312: ;
float c_1275313;
c_1275313 = _1275140.pf32;
p_1275152 = c_1275313;
goto l1275150;
l1275308: ;
float c_1275309;
c_1275309 = _1275143.pf32;
p_1275152 = c_1275309;
goto l1275150;
l1275139: ;
int x_1275144;
x_1275144 = _1275143.qs32;
int y_1275141;
y_1275141 = _1275140.qs32;
int _1275142;
_1275142 = y_1275141 * _1275112;
int _1275145;
_1275145 = _1275142 + x_1275144;
float* idx_1275146;
idx_1275146 = _1043286_1275059 + _1275145;
_1275149 = __ldg(idx_1275146);
p_1275149 = _1275149;
l1275147: ;
_1275149 = p_1275149;
p_1275152 = _1275149;
goto l1275150;
l1275150: ;
_1275152 = p_1275152;
int _1275153;
_1275153 = -1 + gid_x_1275087;
bool _1275154;
_1275154 = _1275153 < 0;
if (_1275154) goto l1275155; else goto l1275303;
l1275303: ;
union variant_220130 _1275304;
_1275304.qs32 = _1275153;
struct_BoundaryMode_220129 _1275305;
_1275305.e0 = 0;
_1275305.e1 = _1275304;
pbh_lower_1275158 = _1275305;
goto l1275156;
l1275155: ;
union variant_220130 _1265919_1853;
_1265919_1853.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1855;
_1265920_1855.e0 = 1;
_1265920_1855.e1 = _1265919_1853;
pbh_lower_1275158 = _1265920_1855;
goto l1275156;
l1275156: ;
bh_lower_1275158 = pbh_lower_1275158;
if (_1275099) goto l1275159; else goto l1275302;
l1275302: ;
pbh_upper_1275162 = _1275289;
goto l1275160;
l1275159: ;
union variant_220130 _1265919_1859;
_1265919_1859.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1861;
_1265920_1861.e0 = 1;
_1265920_1861.e1 = _1265919_1859;
pbh_upper_1275162 = _1265920_1861;
goto l1275160;
l1275160: ;
bh_upper_1275162 = pbh_upper_1275162;
union variant_220130 _1275169;
_1275169 = bh_upper_1275162.e1;
unsigned int _1275163;
_1275163 = bh_lower_1275158.e0;
bool _1275164;
_1275164 = _1275163 == 0;
union variant_220130 _1275172;
_1275172 = bh_lower_1275158.e1;
unsigned int _1275165;
_1275165 = bh_upper_1275162.e0;
bool _1275166;
_1275166 = _1275165 == 0;
bool _1275167;
_1275167 = _1275164 & _1275166;
if (_1275167) goto l1275168; else goto l1275293;
l1275293: ;
bool _1275294;
_1275294 = _1275163 == 1;
if (_1275294) goto l1275295; else goto l1275297;
l1275297: ;
bool _1275298;
_1275298 = _1275165 == 1;
if (_1275298) goto l1275299; else goto l1275301;
l1275301: ;
// bottom: float r4_1265918_1873;
// bottom: p_1275181 = r4_1265918_1873;
goto l1275179;
l1275299: ;
float c_1275300;
c_1275300 = _1275169.pf32;
p_1275181 = c_1275300;
goto l1275179;
l1275295: ;
float c_1275296;
c_1275296 = _1275172.pf32;
p_1275181 = c_1275296;
goto l1275179;
l1275168: ;
int y_1275170;
y_1275170 = _1275169.qs32;
int _1275171;
_1275171 = y_1275170 * _1275112;
int x_1275173;
x_1275173 = _1275172.qs32;
int _1275174;
_1275174 = _1275171 + x_1275173;
float* idx_1275175;
idx_1275175 = _1043286_1275059 + _1275174;
_1275178 = __ldg(idx_1275175);
p_1275178 = _1275178;
l1275176: ;
_1275178 = p_1275178;
p_1275181 = _1275178;
goto l1275179;
l1275179: ;
_1275181 = p_1275181;
int _1275182;
_1275182 = 1 + gid_x_1275087;
bool _1275183;
_1275183 = _1275182 < 0;
if (_1275183) goto l1275184; else goto l1275290;
l1275290: ;
union variant_220130 _1275291;
_1275291.qs32 = _1275182;
struct_BoundaryMode_220129 _1275292;
_1275292.e0 = 0;
_1275292.e1 = _1275291;
pbh_lower_1275187 = _1275292;
goto l1275185;
l1275184: ;
union variant_220130 _1265919_1879;
_1265919_1879.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1881;
_1265920_1881.e0 = 1;
_1265920_1881.e1 = _1265919_1879;
pbh_lower_1275187 = _1265920_1881;
goto l1275185;
l1275185: ;
bh_lower_1275187 = pbh_lower_1275187;
if (_1275099) goto l1275188; else goto l1275287;
l1275287: ;
pbh_upper_1275191 = _1275289;
goto l1275189;
l1275188: ;
union variant_220130 _1265919_1885;
_1265919_1885.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1887;
_1265920_1887.e0 = 1;
_1265920_1887.e1 = _1265919_1885;
pbh_upper_1275191 = _1265920_1887;
goto l1275189;
l1275189: ;
bh_upper_1275191 = pbh_upper_1275191;
unsigned int _1275192;
_1275192 = bh_lower_1275187.e0;
unsigned int _1275194;
_1275194 = bh_upper_1275191.e0;
union variant_220130 _1275201;
_1275201 = bh_lower_1275187.e1;
bool _1275195;
_1275195 = _1275194 == 0;
union variant_220130 _1275198;
_1275198 = bh_upper_1275191.e1;
bool _1275193;
_1275193 = _1275192 == 0;
bool _1275196;
_1275196 = _1275193 & _1275195;
if (_1275196) goto l1275197; else goto l1275278;
l1275278: ;
bool _1275279;
_1275279 = _1275192 == 1;
if (_1275279) goto l1275280; else goto l1275282;
l1275282: ;
bool _1275283;
_1275283 = _1275194 == 1;
if (_1275283) goto l1275284; else goto l1275286;
l1275286: ;
// bottom: float r4_1265918_1899;
// bottom: p_1275210 = r4_1265918_1899;
goto l1275208;
l1275284: ;
float c_1275285;
c_1275285 = _1275198.pf32;
p_1275210 = c_1275285;
goto l1275208;
l1275280: ;
float c_1275281;
c_1275281 = _1275201.pf32;
p_1275210 = c_1275281;
goto l1275208;
l1275197: ;
int y_1275199;
y_1275199 = _1275198.qs32;
int x_1275202;
x_1275202 = _1275201.qs32;
int _1275200;
_1275200 = y_1275199 * _1275112;
int _1275203;
_1275203 = _1275200 + x_1275202;
float* idx_1275204;
idx_1275204 = _1043286_1275059 + _1275203;
_1275207 = __ldg(idx_1275204);
p_1275207 = _1275207;
l1275205: ;
_1275207 = p_1275207;
p_1275210 = _1275207;
goto l1275208;
l1275208: ;
_1275210 = p_1275210;
if (_1275088) goto l1275211; else goto l1275275;
l1275275: ;
pbh_lower_1275214 = _1275277;
goto l1275212;
l1275211: ;
union variant_220130 _1265919_1900;
_1265919_1900.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1902;
_1265920_1902.e0 = 1;
_1265920_1902.e1 = _1265919_1900;
pbh_lower_1275214 = _1265920_1902;
goto l1275212;
l1275212: ;
bh_lower_1275214 = pbh_lower_1275214;
int _1275215;
_1275215 = 1 + gid_y_1275098;
bool _1275216;
_1275216 = _1275093 <= _1275215;
if (_1275216) goto l1275217; else goto l1275272;
l1275272: ;
union variant_220130 _1275273;
_1275273.qs32 = _1275215;
struct_BoundaryMode_220129 _1275274;
_1275274.e0 = 0;
_1275274.e1 = _1275273;
pbh_upper_1275220 = _1275274;
goto l1275218;
l1275217: ;
union variant_220130 _1265919_1910;
_1265919_1910.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1912;
_1265920_1912.e0 = 1;
_1265920_1912.e1 = _1265919_1910;
pbh_upper_1275220 = _1265920_1912;
goto l1275218;
l1275218: ;
bh_upper_1275220 = pbh_upper_1275220;
union variant_220130 _1275230;
_1275230 = bh_lower_1275214.e1;
unsigned int _1275223;
_1275223 = bh_upper_1275220.e0;
unsigned int _1275221;
_1275221 = bh_lower_1275214.e0;
bool _1275224;
_1275224 = _1275223 == 0;
bool _1275222;
_1275222 = _1275221 == 0;
union variant_220130 _1275227;
_1275227 = bh_upper_1275220.e1;
bool _1275225;
_1275225 = _1275222 & _1275224;
if (_1275225) goto l1275226; else goto l1275263;
l1275263: ;
bool _1275264;
_1275264 = _1275221 == 1;
if (_1275264) goto l1275265; else goto l1275267;
l1275267: ;
bool _1275268;
_1275268 = _1275223 == 1;
if (_1275268) goto l1275269; else goto l1275271;
l1275271: ;
// bottom: float r4_1265918_1924;
// bottom: p_1275239 = r4_1265918_1924;
goto l1275237;
l1275269: ;
float c_1275270;
c_1275270 = _1275227.pf32;
p_1275239 = c_1275270;
goto l1275237;
l1275265: ;
float c_1275266;
c_1275266 = _1275230.pf32;
p_1275239 = c_1275266;
goto l1275237;
l1275226: ;
int x_1275231;
x_1275231 = _1275230.qs32;
int y_1275228;
y_1275228 = _1275227.qs32;
int _1275229;
_1275229 = y_1275228 * _1275112;
int _1275232;
_1275232 = _1275229 + x_1275231;
float* idx_1275233;
idx_1275233 = _1043286_1275059 + _1275232;
_1275236 = __ldg(idx_1275233);
p_1275236 = _1275236;
l1275234: ;
_1275236 = p_1275236;
p_1275239 = _1275236;
goto l1275237;
l1275237: ;
_1275239 = p_1275239;
float _1275253;
_1275253 = 2.500000e-01f * _1275152;
float _1275244;
_1275244 = 2.000000e-01f * _1275123;
float _1275259;
_1275259 = 2.500000e-01f * _1275239;
float _1275257;
_1275257 = 2.500000e-01f * _1275210;
int _1275240;
_1275240 = _1043290_1275063.e3;
float _1275250;
_1275250 = _1275249;
float _1275255;
_1275255 = 2.500000e-01f * _1275181;
float _1275254;
_1275254 = 0.000000e+00f + _1275253;
int _1275241;
_1275241 = gid_y_1275098 * _1275240;
float _1275251;
_1275251 = 2.000000e-01f * _1275250;
float _1275256;
_1275256 = _1275254 + _1275255;
int _1275242;
_1275242 = _1275241 + gid_x_1275087;
float _1275252;
_1275252 = _1275244 + _1275251;
float _1275258;
_1275258 = _1275256 + _1275257;
float* idx_1275243;
idx_1275243 = _1043289_1275062 + _1275242;
float _1275260;
_1275260 = _1275258 + _1275259;
float val_1275261;
val_1275261 = _1275252 + _1275260;
*idx_1275243 = val_1275261;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_998005(float* _998008_1273795, float* _998009_1273796, int _998010_1273797, int _998011_1273798) {
int _1273801;
int p_1273801;
int _1273804;
int p_1273804;
int _1273807;
int p_1273807;
int _1273810;
int p_1273810;
int _1273813;
int p_1273813;
int _1273816;
int p_1273816;
int _1273819;
int p_1273819;
int converge_1273828;
int pconverge_1273828;
float _1273837;
float p_1273837;
int converge_1273841;
int pconverge_1273841;
float _1273848;
float p_1273848;
int converge_1273851;
int pconverge_1273851;
float _1273858;
float p_1273858;
int converge_1273861;
int pconverge_1273861;
float _1273868;
float p_1273868;
int converge_1273873;
int pconverge_1273873;
float _1273880;
float p_1273880;
_1273801 = threadIdx_x();
p_1273801 = _1273801;
l1273799: ;
_1273801 = p_1273801;
_1273804 = blockDim_x();
p_1273804 = _1273804;
l1273802: ;
_1273804 = p_1273804;
_1273807 = blockIdx_x();
p_1273807 = _1273807;
l1273805: ;
_1273807 = p_1273807;
_1273810 = threadIdx_y();
p_1273810 = _1273810;
l1273808: ;
_1273810 = p_1273810;
_1273813 = blockDim_y();
p_1273813 = _1273813;
l1273811: ;
_1273813 = p_1273813;
_1273816 = blockIdx_y();
p_1273816 = _1273816;
l1273814: ;
_1273816 = p_1273816;
_1273819 = blockDim_y();
p_1273819 = _1273819;
l1273817: ;
_1273819 = p_1273819;
int _1273822;
_1273822 = _1273813 * _1273816;
int _1273820;
_1273820 = _998010_1273797 - 1;
int _1273821;
_1273821 = _1273820 + _1273810;
int gid_y_1273823;
gid_y_1273823 = _1273821 + _1273822;
int _1273824;
_1273824 = -1 + gid_y_1273823;
bool _1273825;
_1273825 = _998010_1273797 <= _1273824;
if (_1273825) goto l1273826; else goto l1273913;
l1273913: ;
pconverge_1273828 = _1273824;
goto l1273827;
l1273826: ;
int _1273911;
_1273911 = gid_y_1273823 - _998010_1273797;
int _1273912;
_1273912 = _998010_1273797 - _1273911;
pconverge_1273828 = _1273912;
goto l1273827;
l1273827: ;
converge_1273828 = pconverge_1273828;
int _1273829;
_1273829 = converge_1273828 * _998011_1273798;
int _1273830;
_1273830 = _1273804 * _1273807;
int gid_x_1273831;
gid_x_1273831 = _1273801 + _1273830;
int _1273832;
_1273832 = _1273829 + gid_x_1273831;
int _1273833;
_1273833 = 128 + _1273832;
float* idx_1273834;
idx_1273834 = _998008_1273795 + _1273833;
_1273837 = __ldg(idx_1273834);
p_1273837 = _1273837;
l1273835: ;
_1273837 = p_1273837;
bool _1273838;
_1273838 = _998010_1273797 <= gid_y_1273823;
int _1273869;
_1273869 = 1 + gid_y_1273823;
int _1273906;
_1273906 = _1273869 - _998010_1273797;
int _1273907;
_1273907 = _998010_1273797 - _1273906;
if (_1273838) goto l1273839; else goto l1273910;
l1273910: ;
pconverge_1273841 = gid_y_1273823;
goto l1273840;
l1273839: ;
pconverge_1273841 = _1273907;
goto l1273840;
l1273840: ;
converge_1273841 = pconverge_1273841;
int _1273842;
_1273842 = converge_1273841 * _998011_1273798;
int _1273843;
_1273843 = _1273842 + gid_x_1273831;
int _1273844;
_1273844 = 127 + _1273843;
float* idx_1273845;
idx_1273845 = _998008_1273795 + _1273844;
_1273848 = __ldg(idx_1273845);
p_1273848 = _1273848;
l1273846: ;
_1273848 = p_1273848;
if (_1273838) goto l1273849; else goto l1273909;
l1273909: ;
pconverge_1273851 = gid_y_1273823;
goto l1273850;
l1273849: ;
pconverge_1273851 = _1273907;
goto l1273850;
l1273850: ;
converge_1273851 = pconverge_1273851;
int _1273852;
_1273852 = converge_1273851 * _998011_1273798;
int _1273853;
_1273853 = _1273852 + gid_x_1273831;
int _1273854;
_1273854 = 128 + _1273853;
float* idx_1273855;
idx_1273855 = _998008_1273795 + _1273854;
_1273858 = __ldg(idx_1273855);
p_1273858 = _1273858;
l1273856: ;
_1273858 = p_1273858;
if (_1273838) goto l1273859; else goto l1273908;
l1273908: ;
pconverge_1273861 = gid_y_1273823;
goto l1273860;
l1273859: ;
pconverge_1273861 = _1273907;
goto l1273860;
l1273860: ;
converge_1273861 = pconverge_1273861;
int _1273862;
_1273862 = converge_1273861 * _998011_1273798;
int _1273863;
_1273863 = _1273862 + gid_x_1273831;
int _1273864;
_1273864 = 129 + _1273863;
float* idx_1273865;
idx_1273865 = _998008_1273795 + _1273864;
_1273868 = __ldg(idx_1273865);
p_1273868 = _1273868;
l1273866: ;
_1273868 = p_1273868;
bool _1273870;
_1273870 = _998010_1273797 <= _1273869;
if (_1273870) goto l1273871; else goto l1273905;
l1273905: ;
pconverge_1273873 = _1273869;
goto l1273872;
l1273871: ;
int _1273902;
_1273902 = 2 + gid_y_1273823;
int _1273903;
_1273903 = _1273902 - _998010_1273797;
int _1273904;
_1273904 = _998010_1273797 - _1273903;
pconverge_1273873 = _1273904;
goto l1273872;
l1273872: ;
converge_1273873 = pconverge_1273873;
int _1273874;
_1273874 = converge_1273873 * _998011_1273798;
int _1273875;
_1273875 = _1273874 + gid_x_1273831;
int _1273876;
_1273876 = 128 + _1273875;
float* idx_1273877;
idx_1273877 = _998008_1273795 + _1273876;
_1273880 = __ldg(idx_1273877);
p_1273880 = _1273880;
l1273878: ;
_1273880 = p_1273880;
float _1273899;
_1273899 = 1.000000e+00f * _1273880;
float _1273893;
_1273893 = 1.000000e+00f * _1273848;
float _1273891;
_1273891 = 1.000000e+00f * _1273837;
float _1273895;
_1273895 = -4.000000e+00f * _1273858;
float _1273892;
_1273892 = 0.000000e+00f + _1273891;
float _1273897;
_1273897 = 1.000000e+00f * _1273868;
int _1273881;
_1273881 = 4 * _998011_1273798;
float _1273894;
_1273894 = _1273892 + _1273893;
float _1273896;
_1273896 = _1273894 + _1273895;
float _1273898;
_1273898 = _1273896 + _1273897;
int _1273882;
_1273882 = 64 + _1273881;
float _1273900;
_1273900 = _1273898 + _1273899;
int _1273883;
_1273883 = _1273882 - 1;
int _1273884;
_1273884 = _1273883 / 64;
int _1273885;
_1273885 = 64 * _1273884;
int stride_1273886;
stride_1273886 = _1273885 / 4;
int _1273887;
_1273887 = gid_y_1273823 * stride_1273886;
int _1273888;
_1273888 = _1273887 + gid_x_1273831;
int _1273889;
_1273889 = 128 + _1273888;
float* idx_1273890;
idx_1273890 = _998009_1273796 + _1273889;
*idx_1273890 = _1273900;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1033049(float* _1033052_1269343, struct_Img_220118 _1033053_1269344, float* _1033054_1269345, struct_Img_220118 _1033055_1269346, struct_Img_220118 _1033056_1269347, float* _1033057_1269348) {
int _1269351;
int p_1269351;
int _1269354;
int p_1269354;
int _1269357;
int p_1269357;
int _1269360;
int p_1269360;
int _1269363;
int p_1269363;
int _1269366;
int p_1269366;
int _1269369;
int p_1269369;
struct_BoundaryMode_220129 bh_lower_1269376;
struct_BoundaryMode_220129 pbh_lower_1269376;
struct_BoundaryMode_220129 bh_lower_1269383;
struct_BoundaryMode_220129 pbh_lower_1269383;
float _1269400;
float p_1269400;
float _1269403;
float p_1269403;
struct_BoundaryMode_220129 bh_lower_1269407;
struct_BoundaryMode_220129 pbh_lower_1269407;
struct_BoundaryMode_220129 bh_lower_1269413;
struct_BoundaryMode_220129 pbh_lower_1269413;
float _1269429;
float p_1269429;
float _1269432;
float p_1269432;
struct_BoundaryMode_220129 bh_lower_1269438;
struct_BoundaryMode_220129 pbh_lower_1269438;
struct_BoundaryMode_220129 bh_lower_1269442;
struct_BoundaryMode_220129 pbh_lower_1269442;
float _1269458;
float p_1269458;
float _1269461;
float p_1269461;
struct_BoundaryMode_220129 bh_lower_1269467;
struct_BoundaryMode_220129 pbh_lower_1269467;
struct_BoundaryMode_220129 bh_lower_1269471;
struct_BoundaryMode_220129 pbh_lower_1269471;
float _1269487;
float p_1269487;
float _1269490;
float p_1269490;
struct_BoundaryMode_220129 bh_lower_1269494;
struct_BoundaryMode_220129 pbh_lower_1269494;
struct_BoundaryMode_220129 bh_lower_1269500;
struct_BoundaryMode_220129 pbh_lower_1269500;
float _1269516;
float p_1269516;
float _1269519;
float p_1269519;
_1269351 = threadIdx_x();
p_1269351 = _1269351;
l1269349: ;
_1269351 = p_1269351;
_1269354 = blockDim_x();
p_1269354 = _1269354;
l1269352: ;
_1269354 = p_1269354;
_1269357 = blockIdx_x();
p_1269357 = _1269357;
l1269355: ;
_1269357 = p_1269357;
_1269360 = threadIdx_y();
p_1269360 = _1269360;
l1269358: ;
_1269360 = p_1269360;
_1269363 = blockDim_y();
p_1269363 = _1269363;
l1269361: ;
_1269363 = p_1269363;
_1269366 = blockIdx_y();
p_1269366 = _1269366;
l1269364: ;
_1269366 = p_1269366;
_1269369 = blockDim_y();
p_1269369 = _1269369;
l1269367: ;
_1269369 = p_1269369;
int _1269370;
_1269370 = _1269354 * _1269357;
int gid_x_1269371;
gid_x_1269371 = _1269351 + _1269370;
union variant_220130 _1269556;
_1269556.qs32 = gid_x_1269371;
bool _1269372;
_1269372 = gid_x_1269371 < 0;
struct_BoundaryMode_220129 _1269557;
_1269557.e0 = 0;
_1269557.e1 = _1269556;
if (_1269372) goto l1269373; else goto l1269610;
l1269610: ;
pbh_lower_1269376 = _1269557;
goto l1269374;
l1269373: ;
union variant_220130 _1265919_1959;
_1265919_1959.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1961;
_1265920_1961.e0 = 1;
_1265920_1961.e1 = _1265919_1959;
pbh_lower_1269376 = _1265920_1961;
goto l1269374;
l1269374: ;
bh_lower_1269376 = pbh_lower_1269376;
int _1269377;
_1269377 = _1269363 * _1269366;
int gid_y_1269378;
gid_y_1269378 = _1269360 + _1269377;
bool _1269379;
_1269379 = gid_y_1269378 < 0;
union variant_220130 _1269568;
_1269568.qs32 = gid_y_1269378;
struct_BoundaryMode_220129 _1269569;
_1269569.e0 = 0;
_1269569.e1 = _1269568;
if (_1269379) goto l1269380; else goto l1269609;
l1269609: ;
pbh_lower_1269383 = _1269569;
goto l1269381;
l1269380: ;
union variant_220130 _1265919_1969;
_1265919_1969.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1971;
_1265920_1971.e0 = 1;
_1265920_1971.e1 = _1265919_1969;
pbh_lower_1269383 = _1265920_1971;
goto l1269381;
l1269381: ;
bh_lower_1269383 = pbh_lower_1269383;
unsigned int _1269384;
_1269384 = bh_lower_1269376.e0;
union variant_220130 _1269390;
_1269390 = bh_lower_1269383.e1;
bool _1269385;
_1269385 = _1269384 == 0;
unsigned int _1269386;
_1269386 = bh_lower_1269383.e0;
bool _1269387;
_1269387 = _1269386 == 0;
bool _1269388;
_1269388 = _1269385 & _1269387;
union variant_220130 _1269394;
_1269394 = bh_lower_1269376.e1;
int _1269392;
_1269392 = _1033055_1269346.e3;
if (_1269388) goto l1269389; else goto l1269600;
l1269600: ;
bool _1269601;
_1269601 = _1269384 == 1;
if (_1269601) goto l1269602; else goto l1269604;
l1269604: ;
bool _1269605;
_1269605 = _1269386 == 1;
if (_1269605) goto l1269606; else goto l1269608;
l1269608: ;
// bottom: float r4_1265918_1984;
// bottom: p_1269403 = r4_1265918_1984;
goto l1269401;
l1269606: ;
float c_1269607;
c_1269607 = _1269390.pf32;
p_1269403 = c_1269607;
goto l1269401;
l1269602: ;
float c_1269603;
c_1269603 = _1269394.pf32;
p_1269403 = c_1269603;
goto l1269401;
l1269389: ;
int x_1269395;
x_1269395 = _1269394.qs32;
int y_1269391;
y_1269391 = _1269390.qs32;
int _1269393;
_1269393 = y_1269391 * _1269392;
int _1269396;
_1269396 = _1269393 + x_1269395;
float* idx_1269397;
idx_1269397 = _1033054_1269345 + _1269396;
_1269400 = __ldg(idx_1269397);
p_1269400 = _1269400;
l1269398: ;
_1269400 = p_1269400;
p_1269403 = _1269400;
goto l1269401;
l1269401: ;
_1269403 = p_1269403;
int _1269525;
_1269525 = _1033053_1269344.e3;
int _1269526;
_1269526 = gid_y_1269378 * _1269525;
int _1269527;
_1269527 = _1269526 + gid_x_1269371;
float* idx_1269528;
idx_1269528 = _1033057_1269348 + _1269527;
float _1269529;
_1269529 = *idx_1269528;
if (_1269372) goto l1269404; else goto l1269599;
l1269599: ;
pbh_lower_1269407 = _1269557;
goto l1269405;
l1269404: ;
union variant_220130 _1265919_1986;
_1265919_1986.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1988;
_1265920_1988.e0 = 1;
_1265920_1988.e1 = _1265919_1986;
pbh_lower_1269407 = _1265920_1988;
goto l1269405;
l1269405: ;
bh_lower_1269407 = pbh_lower_1269407;
int _1269408;
_1269408 = -1 + gid_y_1269378;
bool _1269409;
_1269409 = _1269408 < 0;
if (_1269409) goto l1269410; else goto l1269595;
l1269595: ;
union variant_220130 _1269596;
_1269596.qs32 = _1269408;
struct_BoundaryMode_220129 _1269597;
_1269597.e0 = 0;
_1269597.e1 = _1269596;
pbh_lower_1269413 = _1269597;
goto l1269411;
l1269410: ;
union variant_220130 _1265919_1997;
_1265919_1997.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_1999;
_1265920_1999.e0 = 1;
_1265920_1999.e1 = _1265919_1997;
pbh_lower_1269413 = _1265920_1999;
goto l1269411;
l1269411: ;
bh_lower_1269413 = pbh_lower_1269413;
unsigned int _1269414;
_1269414 = bh_lower_1269407.e0;
union variant_220130 _1269423;
_1269423 = bh_lower_1269407.e1;
unsigned int _1269416;
_1269416 = bh_lower_1269413.e0;
bool _1269415;
_1269415 = _1269414 == 0;
bool _1269417;
_1269417 = _1269416 == 0;
union variant_220130 _1269420;
_1269420 = bh_lower_1269413.e1;
bool _1269418;
_1269418 = _1269415 & _1269417;
if (_1269418) goto l1269419; else goto l1269586;
l1269586: ;
bool _1269587;
_1269587 = _1269414 == 1;
if (_1269587) goto l1269588; else goto l1269590;
l1269590: ;
bool _1269591;
_1269591 = _1269416 == 1;
if (_1269591) goto l1269592; else goto l1269594;
l1269594: ;
// bottom: float r4_1265918_2011;
// bottom: p_1269432 = r4_1265918_2011;
goto l1269430;
l1269592: ;
float c_1269593;
c_1269593 = _1269420.pf32;
p_1269432 = c_1269593;
goto l1269430;
l1269588: ;
float c_1269589;
c_1269589 = _1269423.pf32;
p_1269432 = c_1269589;
goto l1269430;
l1269419: ;
int y_1269421;
y_1269421 = _1269420.qs32;
int x_1269424;
x_1269424 = _1269423.qs32;
int _1269422;
_1269422 = y_1269421 * _1269392;
int _1269425;
_1269425 = _1269422 + x_1269424;
float* idx_1269426;
idx_1269426 = _1033054_1269345 + _1269425;
_1269429 = __ldg(idx_1269426);
p_1269429 = _1269429;
l1269427: ;
_1269429 = p_1269429;
p_1269432 = _1269429;
goto l1269430;
l1269430: ;
_1269432 = p_1269432;
int _1269433;
_1269433 = -1 + gid_x_1269371;
bool _1269434;
_1269434 = _1269433 < 0;
if (_1269434) goto l1269435; else goto l1269583;
l1269583: ;
union variant_220130 _1269584;
_1269584.qs32 = _1269433;
struct_BoundaryMode_220129 _1269585;
_1269585.e0 = 0;
_1269585.e1 = _1269584;
pbh_lower_1269438 = _1269585;
goto l1269436;
l1269435: ;
union variant_220130 _1265919_2017;
_1265919_2017.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2019;
_1265920_2019.e0 = 1;
_1265920_2019.e1 = _1265919_2017;
pbh_lower_1269438 = _1265920_2019;
goto l1269436;
l1269436: ;
bh_lower_1269438 = pbh_lower_1269438;
if (_1269379) goto l1269439; else goto l1269582;
l1269582: ;
pbh_lower_1269442 = _1269569;
goto l1269440;
l1269439: ;
union variant_220130 _1265919_2023;
_1265919_2023.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2025;
_1265920_2025.e0 = 1;
_1265920_2025.e1 = _1265919_2023;
pbh_lower_1269442 = _1265920_2025;
goto l1269440;
l1269440: ;
bh_lower_1269442 = pbh_lower_1269442;
union variant_220130 _1269449;
_1269449 = bh_lower_1269442.e1;
union variant_220130 _1269452;
_1269452 = bh_lower_1269438.e1;
unsigned int _1269445;
_1269445 = bh_lower_1269442.e0;
unsigned int _1269443;
_1269443 = bh_lower_1269438.e0;
bool _1269446;
_1269446 = _1269445 == 0;
bool _1269444;
_1269444 = _1269443 == 0;
bool _1269447;
_1269447 = _1269444 & _1269446;
if (_1269447) goto l1269448; else goto l1269573;
l1269573: ;
bool _1269574;
_1269574 = _1269443 == 1;
if (_1269574) goto l1269575; else goto l1269577;
l1269577: ;
bool _1269578;
_1269578 = _1269445 == 1;
if (_1269578) goto l1269579; else goto l1269581;
l1269581: ;
// bottom: float r4_1265918_2037;
// bottom: p_1269461 = r4_1265918_2037;
goto l1269459;
l1269579: ;
float c_1269580;
c_1269580 = _1269449.pf32;
p_1269461 = c_1269580;
goto l1269459;
l1269575: ;
float c_1269576;
c_1269576 = _1269452.pf32;
p_1269461 = c_1269576;
goto l1269459;
l1269448: ;
int y_1269450;
y_1269450 = _1269449.qs32;
int x_1269453;
x_1269453 = _1269452.qs32;
int _1269451;
_1269451 = y_1269450 * _1269392;
int _1269454;
_1269454 = _1269451 + x_1269453;
float* idx_1269455;
idx_1269455 = _1033054_1269345 + _1269454;
_1269458 = __ldg(idx_1269455);
p_1269458 = _1269458;
l1269456: ;
_1269458 = p_1269458;
p_1269461 = _1269458;
goto l1269459;
l1269459: ;
_1269461 = p_1269461;
int _1269462;
_1269462 = 1 + gid_x_1269371;
bool _1269463;
_1269463 = _1269462 < 0;
if (_1269463) goto l1269464; else goto l1269570;
l1269570: ;
union variant_220130 _1269571;
_1269571.qs32 = _1269462;
struct_BoundaryMode_220129 _1269572;
_1269572.e0 = 0;
_1269572.e1 = _1269571;
pbh_lower_1269467 = _1269572;
goto l1269465;
l1269464: ;
union variant_220130 _1265919_2043;
_1265919_2043.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2045;
_1265920_2045.e0 = 1;
_1265920_2045.e1 = _1265919_2043;
pbh_lower_1269467 = _1265920_2045;
goto l1269465;
l1269465: ;
bh_lower_1269467 = pbh_lower_1269467;
if (_1269379) goto l1269468; else goto l1269567;
l1269567: ;
pbh_lower_1269471 = _1269569;
goto l1269469;
l1269468: ;
union variant_220130 _1265919_2049;
_1265919_2049.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2051;
_1265920_2051.e0 = 1;
_1265920_2051.e1 = _1265919_2049;
pbh_lower_1269471 = _1265920_2051;
goto l1269469;
l1269469: ;
bh_lower_1269471 = pbh_lower_1269471;
union variant_220130 _1269478;
_1269478 = bh_lower_1269471.e1;
unsigned int _1269472;
_1269472 = bh_lower_1269467.e0;
union variant_220130 _1269481;
_1269481 = bh_lower_1269467.e1;
unsigned int _1269474;
_1269474 = bh_lower_1269471.e0;
bool _1269473;
_1269473 = _1269472 == 0;
bool _1269475;
_1269475 = _1269474 == 0;
bool _1269476;
_1269476 = _1269473 & _1269475;
if (_1269476) goto l1269477; else goto l1269558;
l1269558: ;
bool _1269559;
_1269559 = _1269472 == 1;
if (_1269559) goto l1269560; else goto l1269562;
l1269562: ;
bool _1269563;
_1269563 = _1269474 == 1;
if (_1269563) goto l1269564; else goto l1269566;
l1269566: ;
// bottom: float r4_1265918_2063;
// bottom: p_1269490 = r4_1265918_2063;
goto l1269488;
l1269564: ;
float c_1269565;
c_1269565 = _1269478.pf32;
p_1269490 = c_1269565;
goto l1269488;
l1269560: ;
float c_1269561;
c_1269561 = _1269481.pf32;
p_1269490 = c_1269561;
goto l1269488;
l1269477: ;
int y_1269479;
y_1269479 = _1269478.qs32;
int x_1269482;
x_1269482 = _1269481.qs32;
int _1269480;
_1269480 = y_1269479 * _1269392;
int _1269483;
_1269483 = _1269480 + x_1269482;
float* idx_1269484;
idx_1269484 = _1033054_1269345 + _1269483;
_1269487 = __ldg(idx_1269484);
p_1269487 = _1269487;
l1269485: ;
_1269487 = p_1269487;
p_1269490 = _1269487;
goto l1269488;
l1269488: ;
_1269490 = p_1269490;
if (_1269372) goto l1269491; else goto l1269555;
l1269555: ;
pbh_lower_1269494 = _1269557;
goto l1269492;
l1269491: ;
union variant_220130 _1265919_2064;
_1265919_2064.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2066;
_1265920_2066.e0 = 1;
_1265920_2066.e1 = _1265919_2064;
pbh_lower_1269494 = _1265920_2066;
goto l1269492;
l1269492: ;
bh_lower_1269494 = pbh_lower_1269494;
int _1269495;
_1269495 = 1 + gid_y_1269378;
bool _1269496;
_1269496 = _1269495 < 0;
if (_1269496) goto l1269497; else goto l1269552;
l1269552: ;
union variant_220130 _1269553;
_1269553.qs32 = _1269495;
struct_BoundaryMode_220129 _1269554;
_1269554.e0 = 0;
_1269554.e1 = _1269553;
pbh_lower_1269500 = _1269554;
goto l1269498;
l1269497: ;
union variant_220130 _1265919_2075;
_1265919_2075.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2077;
_1265920_2077.e0 = 1;
_1265920_2077.e1 = _1265919_2075;
pbh_lower_1269500 = _1265920_2077;
goto l1269498;
l1269498: ;
bh_lower_1269500 = pbh_lower_1269500;
unsigned int _1269503;
_1269503 = bh_lower_1269500.e0;
union variant_220130 _1269507;
_1269507 = bh_lower_1269500.e1;
bool _1269504;
_1269504 = _1269503 == 0;
unsigned int _1269501;
_1269501 = bh_lower_1269494.e0;
union variant_220130 _1269510;
_1269510 = bh_lower_1269494.e1;
bool _1269502;
_1269502 = _1269501 == 0;
bool _1269505;
_1269505 = _1269502 & _1269504;
if (_1269505) goto l1269506; else goto l1269543;
l1269543: ;
bool _1269544;
_1269544 = _1269501 == 1;
if (_1269544) goto l1269545; else goto l1269547;
l1269547: ;
bool _1269548;
_1269548 = _1269503 == 1;
if (_1269548) goto l1269549; else goto l1269551;
l1269551: ;
// bottom: float r4_1265918_2089;
// bottom: p_1269519 = r4_1265918_2089;
goto l1269517;
l1269549: ;
float c_1269550;
c_1269550 = _1269507.pf32;
p_1269519 = c_1269550;
goto l1269517;
l1269545: ;
float c_1269546;
c_1269546 = _1269510.pf32;
p_1269519 = c_1269546;
goto l1269517;
l1269506: ;
int x_1269511;
x_1269511 = _1269510.qs32;
int y_1269508;
y_1269508 = _1269507.qs32;
int _1269509;
_1269509 = y_1269508 * _1269392;
int _1269512;
_1269512 = _1269509 + x_1269511;
float* idx_1269513;
idx_1269513 = _1033054_1269345 + _1269512;
_1269516 = __ldg(idx_1269513);
p_1269516 = _1269516;
l1269514: ;
_1269516 = p_1269516;
p_1269519 = _1269516;
goto l1269517;
l1269517: ;
_1269519 = p_1269519;
int _1269520;
_1269520 = _1033056_1269347.e3;
float _1269537;
_1269537 = 2.500000e-01f * _1269490;
float _1269524;
_1269524 = 2.000000e-01f * _1269403;
int _1269521;
_1269521 = gid_y_1269378 * _1269520;
float _1269533;
_1269533 = 2.500000e-01f * _1269432;
float _1269539;
_1269539 = 2.500000e-01f * _1269519;
float _1269535;
_1269535 = 2.500000e-01f * _1269461;
float _1269530;
_1269530 = _1269529;
int _1269522;
_1269522 = _1269521 + gid_x_1269371;
float _1269534;
_1269534 = 0.000000e+00f + _1269533;
float _1269536;
_1269536 = _1269534 + _1269535;
float _1269531;
_1269531 = 2.000000e-01f * _1269530;
float* idx_1269523;
idx_1269523 = _1033052_1269343 + _1269522;
float _1269538;
_1269538 = _1269536 + _1269537;
float _1269532;
_1269532 = _1269524 + _1269531;
float _1269540;
_1269540 = _1269538 + _1269539;
float val_1269541;
val_1269541 = _1269532 + _1269540;
*idx_1269523 = val_1269541;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1016430(struct_Img_220118 _1016433_1282292, float* _1016434_1282293, struct_Img_220118 _1016435_1282294, float* _1016436_1282295, struct_Img_220118 _1016437_1282296, float* _1016438_1282297) {
int _1282300;
int p_1282300;
int _1282303;
int p_1282303;
int _1282306;
int p_1282306;
int _1282309;
int p_1282309;
int _1282312;
int p_1282312;
int _1282315;
int p_1282315;
int _1282318;
int p_1282318;
struct_BoundaryMode_220129 bh_upper_1282329;
struct_BoundaryMode_220129 pbh_upper_1282329;
float _1282344;
float p_1282344;
float _1282347;
float p_1282347;
struct_BoundaryMode_220129 bh_upper_1282353;
struct_BoundaryMode_220129 pbh_upper_1282353;
float _1282365;
float p_1282365;
float _1282368;
float p_1282368;
struct_BoundaryMode_220129 bh_upper_1282372;
struct_BoundaryMode_220129 pbh_upper_1282372;
float _1282384;
float p_1282384;
float _1282387;
float p_1282387;
struct_BoundaryMode_220129 bh_upper_1282391;
struct_BoundaryMode_220129 pbh_upper_1282391;
float _1282403;
float p_1282403;
float _1282406;
float p_1282406;
struct_BoundaryMode_220129 bh_upper_1282412;
struct_BoundaryMode_220129 pbh_upper_1282412;
float _1282424;
float p_1282424;
float _1282427;
float p_1282427;
_1282300 = threadIdx_x();
p_1282300 = _1282300;
l1282298: ;
_1282300 = p_1282300;
_1282303 = blockDim_x();
p_1282303 = _1282303;
l1282301: ;
_1282303 = p_1282303;
_1282306 = blockIdx_x();
p_1282306 = _1282306;
l1282304: ;
_1282306 = p_1282306;
_1282309 = threadIdx_y();
p_1282309 = _1282309;
l1282307: ;
_1282309 = p_1282309;
_1282312 = blockDim_y();
p_1282312 = _1282312;
l1282310: ;
_1282312 = p_1282312;
_1282315 = blockIdx_y();
p_1282315 = _1282315;
l1282313: ;
_1282315 = p_1282315;
_1282318 = blockDim_y();
p_1282318 = _1282318;
l1282316: ;
_1282318 = p_1282318;
int _1282323;
_1282323 = _1282312 * _1282315;
int _1282320;
_1282320 = _1016435_1282294.e2;
int _1282319;
_1282319 = _1016437_1282296.e2;
int _1282321;
_1282321 = _1282320 - 1;
int _1282322;
_1282322 = _1282321 + _1282309;
int gid_y_1282324;
gid_y_1282324 = _1282322 + _1282323;
union variant_220130 _1282467;
_1282467.qs32 = gid_y_1282324;
bool _1282325;
_1282325 = _1282319 <= gid_y_1282324;
struct_BoundaryMode_220129 _1282468;
_1282468.e0 = 0;
_1282468.e1 = _1282467;
if (_1282325) goto l1282326; else goto l1282489;
l1282489: ;
pbh_upper_1282329 = _1282468;
goto l1282327;
l1282326: ;
union variant_220130 _1265919_2104;
_1265919_2104.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2106;
_1265920_2106.e0 = 1;
_1265920_2106.e1 = _1265919_2104;
pbh_upper_1282329 = _1265920_2106;
goto l1282327;
l1282327: ;
bh_upper_1282329 = pbh_upper_1282329;
unsigned int _1282330;
_1282330 = bh_upper_1282329.e0;
union variant_220130 _1282333;
_1282333 = bh_upper_1282329.e1;
int _1282335;
_1282335 = _1016437_1282296.e3;
int _1282337;
_1282337 = _1282303 * _1282306;
int gid_x_1282338;
gid_x_1282338 = _1282300 + _1282337;
bool _1282331;
_1282331 = _1282330 == 0;
if (_1282331) goto l1282332; else goto l1282484;
l1282484: ;
bool _1282485;
_1282485 = _1282330 == 1;
if (_1282485) goto l1282486; else goto l1282488;
l1282488: ;
// bottom: float r4_1265918_2115;
// bottom: p_1282347 = r4_1265918_2115;
goto l1282345;
l1282486: ;
float c_1282487;
c_1282487 = _1282333.pf32;
p_1282347 = c_1282487;
goto l1282345;
l1282332: ;
int y_1282334;
y_1282334 = _1282333.qs32;
int _1282336;
_1282336 = y_1282334 * _1282335;
int _1282339;
_1282339 = _1282336 + gid_x_1282338;
int _1282340;
_1282340 = 128 + _1282339;
float* idx_1282341;
idx_1282341 = _1016436_1282295 + _1282340;
_1282344 = __ldg(idx_1282341);
p_1282344 = _1282344;
l1282342: ;
_1282344 = p_1282344;
p_1282347 = _1282344;
goto l1282345;
l1282345: ;
_1282347 = p_1282347;
int _1282348;
_1282348 = -1 + gid_y_1282324;
int _1282434;
_1282434 = _1016433_1282292.e3;
int _1282435;
_1282435 = gid_y_1282324 * _1282434;
bool _1282349;
_1282349 = _1282319 <= _1282348;
int _1282436;
_1282436 = _1282435 + gid_x_1282338;
int _1282437;
_1282437 = 128 + _1282436;
float* idx_1282438;
idx_1282438 = _1016438_1282297 + _1282437;
float _1282439;
_1282439 = *idx_1282438;
if (_1282349) goto l1282350; else goto l1282481;
l1282481: ;
union variant_220130 _1282482;
_1282482.qs32 = _1282348;
struct_BoundaryMode_220129 _1282483;
_1282483.e0 = 0;
_1282483.e1 = _1282482;
pbh_upper_1282353 = _1282483;
goto l1282351;
l1282350: ;
union variant_220130 _1265919_2123;
_1265919_2123.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2125;
_1265920_2125.e0 = 1;
_1265920_2125.e1 = _1265919_2123;
pbh_upper_1282353 = _1265920_2125;
goto l1282351;
l1282351: ;
bh_upper_1282353 = pbh_upper_1282353;
unsigned int _1282354;
_1282354 = bh_upper_1282353.e0;
bool _1282355;
_1282355 = _1282354 == 0;
union variant_220130 _1282357;
_1282357 = bh_upper_1282353.e1;
if (_1282355) goto l1282356; else goto l1282475;
l1282475: ;
bool _1282476;
_1282476 = _1282354 == 1;
if (_1282476) goto l1282477; else goto l1282479;
l1282479: ;
// bottom: float r4_1265918_2133;
// bottom: p_1282368 = r4_1265918_2133;
goto l1282366;
l1282477: ;
float c_1282478;
c_1282478 = _1282357.pf32;
p_1282368 = c_1282478;
goto l1282366;
l1282356: ;
int y_1282358;
y_1282358 = _1282357.qs32;
int _1282359;
_1282359 = y_1282358 * _1282335;
int _1282360;
_1282360 = _1282359 + gid_x_1282338;
int _1282361;
_1282361 = 128 + _1282360;
float* idx_1282362;
idx_1282362 = _1016436_1282295 + _1282361;
_1282365 = __ldg(idx_1282362);
p_1282365 = _1282365;
l1282363: ;
_1282365 = p_1282365;
p_1282368 = _1282365;
goto l1282366;
l1282366: ;
_1282368 = p_1282368;
if (_1282325) goto l1282369; else goto l1282474;
l1282474: ;
pbh_upper_1282372 = _1282468;
goto l1282370;
l1282369: ;
union variant_220130 _1265919_2135;
_1265919_2135.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2137;
_1265920_2137.e0 = 1;
_1265920_2137.e1 = _1265919_2135;
pbh_upper_1282372 = _1265920_2137;
goto l1282370;
l1282370: ;
bh_upper_1282372 = pbh_upper_1282372;
union variant_220130 _1282376;
_1282376 = bh_upper_1282372.e1;
unsigned int _1282373;
_1282373 = bh_upper_1282372.e0;
bool _1282374;
_1282374 = _1282373 == 0;
if (_1282374) goto l1282375; else goto l1282469;
l1282469: ;
bool _1282470;
_1282470 = _1282373 == 1;
if (_1282470) goto l1282471; else goto l1282473;
l1282473: ;
// bottom: float r4_1265918_2145;
// bottom: p_1282387 = r4_1265918_2145;
goto l1282385;
l1282471: ;
float c_1282472;
c_1282472 = _1282376.pf32;
p_1282387 = c_1282472;
goto l1282385;
l1282375: ;
int y_1282377;
y_1282377 = _1282376.qs32;
int _1282378;
_1282378 = y_1282377 * _1282335;
int _1282379;
_1282379 = _1282378 + gid_x_1282338;
int _1282380;
_1282380 = 127 + _1282379;
float* idx_1282381;
idx_1282381 = _1016436_1282295 + _1282380;
_1282384 = __ldg(idx_1282381);
p_1282384 = _1282384;
l1282382: ;
_1282384 = p_1282384;
p_1282387 = _1282384;
goto l1282385;
l1282385: ;
_1282387 = p_1282387;
if (_1282325) goto l1282388; else goto l1282466;
l1282466: ;
pbh_upper_1282391 = _1282468;
goto l1282389;
l1282388: ;
union variant_220130 _1265919_2147;
_1265919_2147.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2149;
_1265920_2149.e0 = 1;
_1265920_2149.e1 = _1265919_2147;
pbh_upper_1282391 = _1265920_2149;
goto l1282389;
l1282389: ;
bh_upper_1282391 = pbh_upper_1282391;
union variant_220130 _1282395;
_1282395 = bh_upper_1282391.e1;
unsigned int _1282392;
_1282392 = bh_upper_1282391.e0;
bool _1282393;
_1282393 = _1282392 == 0;
if (_1282393) goto l1282394; else goto l1282461;
l1282461: ;
bool _1282462;
_1282462 = _1282392 == 1;
if (_1282462) goto l1282463; else goto l1282465;
l1282465: ;
// bottom: float r4_1265918_2157;
// bottom: p_1282406 = r4_1265918_2157;
goto l1282404;
l1282463: ;
float c_1282464;
c_1282464 = _1282395.pf32;
p_1282406 = c_1282464;
goto l1282404;
l1282394: ;
int y_1282396;
y_1282396 = _1282395.qs32;
int _1282397;
_1282397 = y_1282396 * _1282335;
int _1282398;
_1282398 = _1282397 + gid_x_1282338;
int _1282399;
_1282399 = 129 + _1282398;
float* idx_1282400;
idx_1282400 = _1016436_1282295 + _1282399;
_1282403 = __ldg(idx_1282400);
p_1282403 = _1282403;
l1282401: ;
_1282403 = p_1282403;
p_1282406 = _1282403;
goto l1282404;
l1282404: ;
_1282406 = p_1282406;
int _1282407;
_1282407 = 1 + gid_y_1282324;
bool _1282408;
_1282408 = _1282319 <= _1282407;
if (_1282408) goto l1282409; else goto l1282458;
l1282458: ;
union variant_220130 _1282459;
_1282459.qs32 = _1282407;
struct_BoundaryMode_220129 _1282460;
_1282460.e0 = 0;
_1282460.e1 = _1282459;
pbh_upper_1282412 = _1282460;
goto l1282410;
l1282409: ;
union variant_220130 _1265919_2163;
_1265919_2163.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2165;
_1265920_2165.e0 = 1;
_1265920_2165.e1 = _1265919_2163;
pbh_upper_1282412 = _1265920_2165;
goto l1282410;
l1282410: ;
bh_upper_1282412 = pbh_upper_1282412;
union variant_220130 _1282416;
_1282416 = bh_upper_1282412.e1;
unsigned int _1282413;
_1282413 = bh_upper_1282412.e0;
bool _1282414;
_1282414 = _1282413 == 0;
if (_1282414) goto l1282415; else goto l1282453;
l1282453: ;
bool _1282454;
_1282454 = _1282413 == 1;
if (_1282454) goto l1282455; else goto l1282457;
l1282457: ;
// bottom: float r4_1265918_2173;
// bottom: p_1282427 = r4_1265918_2173;
goto l1282425;
l1282455: ;
float c_1282456;
c_1282456 = _1282416.pf32;
p_1282427 = c_1282456;
goto l1282425;
l1282415: ;
int y_1282417;
y_1282417 = _1282416.qs32;
int _1282418;
_1282418 = y_1282417 * _1282335;
int _1282419;
_1282419 = _1282418 + gid_x_1282338;
int _1282420;
_1282420 = 128 + _1282419;
float* idx_1282421;
idx_1282421 = _1016436_1282295 + _1282420;
_1282424 = __ldg(idx_1282421);
p_1282424 = _1282424;
l1282422: ;
_1282424 = p_1282424;
p_1282427 = _1282424;
goto l1282425;
l1282425: ;
_1282427 = p_1282427;
float _1282447;
_1282447 = 2.500000e-01f * _1282406;
float _1282445;
_1282445 = 2.500000e-01f * _1282387;
float _1282433;
_1282433 = 2.000000e-01f * _1282347;
int _1282428;
_1282428 = _1016435_1282294.e3;
int _1282429;
_1282429 = gid_y_1282324 * _1282428;
float _1282449;
_1282449 = 2.500000e-01f * _1282427;
float _1282443;
_1282443 = 2.500000e-01f * _1282368;
float _1282440;
_1282440 = _1282439;
int _1282430;
_1282430 = _1282429 + gid_x_1282338;
float _1282444;
_1282444 = 0.000000e+00f + _1282443;
float _1282441;
_1282441 = 2.000000e-01f * _1282440;
int _1282431;
_1282431 = 128 + _1282430;
float _1282446;
_1282446 = _1282444 + _1282445;
float _1282442;
_1282442 = _1282433 + _1282441;
float* idx_1282432;
idx_1282432 = _1016434_1282293 + _1282431;
float _1282448;
_1282448 = _1282446 + _1282447;
float _1282450;
_1282450 = _1282448 + _1282449;
float val_1282451;
val_1282451 = _1282442 + _1282450;
*idx_1282432 = val_1282451;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1027205(struct_Img_220118 _1027208_1284809, float* _1027209_1284810, struct_Img_220118 _1027210_1284811, float* _1027211_1284812, float* _1027212_1284813, struct_Img_220118 _1027213_1284814) {
int _1284817;
int p_1284817;
int _1284820;
int p_1284820;
int _1284823;
int p_1284823;
int _1284826;
int p_1284826;
int _1284829;
int p_1284829;
int _1284832;
int p_1284832;
int _1284835;
int p_1284835;
struct_BoundaryMode_220129 bh_upper_1284846;
struct_BoundaryMode_220129 pbh_upper_1284846;
float _1284861;
float p_1284861;
float _1284864;
float p_1284864;
struct_BoundaryMode_220129 bh_upper_1284868;
struct_BoundaryMode_220129 pbh_upper_1284868;
float _1284879;
float p_1284879;
float _1284882;
float p_1284882;
struct_BoundaryMode_220129 bh_upper_1284888;
struct_BoundaryMode_220129 pbh_upper_1284888;
float _1284898;
float p_1284898;
float _1284901;
float p_1284901;
struct_BoundaryMode_220129 bh_upper_1284907;
struct_BoundaryMode_220129 pbh_upper_1284907;
float _1284917;
float p_1284917;
float _1284920;
float p_1284920;
struct_BoundaryMode_220129 bh_upper_1284924;
struct_BoundaryMode_220129 pbh_upper_1284924;
float _1284936;
float p_1284936;
float _1284939;
float p_1284939;
_1284817 = threadIdx_x();
p_1284817 = _1284817;
l1284815: ;
_1284817 = p_1284817;
_1284820 = blockDim_x();
p_1284820 = _1284820;
l1284818: ;
_1284820 = p_1284820;
_1284823 = blockIdx_x();
p_1284823 = _1284823;
l1284821: ;
_1284823 = p_1284823;
_1284826 = threadIdx_y();
p_1284826 = _1284826;
l1284824: ;
_1284826 = p_1284826;
_1284829 = blockDim_y();
p_1284829 = _1284829;
l1284827: ;
_1284829 = p_1284829;
_1284832 = blockIdx_y();
p_1284832 = _1284832;
l1284830: ;
_1284832 = p_1284832;
_1284835 = blockDim_y();
p_1284835 = _1284835;
l1284833: ;
_1284835 = p_1284835;
int _1284840;
_1284840 = _1284820 * _1284823;
int _1284837;
_1284837 = _1027210_1284811.e1;
int _1284836;
_1284836 = _1027208_1284809.e1;
int _1284838;
_1284838 = _1284837 - 128;
int _1284839;
_1284839 = _1284838 + _1284817;
int gid_x_1284841;
gid_x_1284841 = _1284839 + _1284840;
bool _1284842;
_1284842 = _1284836 <= gid_x_1284841;
union variant_220130 _1284969;
_1284969.qs32 = gid_x_1284841;
struct_BoundaryMode_220129 _1284970;
_1284970.e0 = 0;
_1284970.e1 = _1284969;
if (_1284842) goto l1284843; else goto l1284999;
l1284999: ;
pbh_upper_1284846 = _1284970;
goto l1284844;
l1284843: ;
union variant_220130 _1265919_2190;
_1265919_2190.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2192;
_1265920_2192.e0 = 1;
_1265920_2192.e1 = _1265919_2190;
pbh_upper_1284846 = _1265920_2192;
goto l1284844;
l1284844: ;
bh_upper_1284846 = pbh_upper_1284846;
union variant_220130 _1284855;
_1284855 = bh_upper_1284846.e1;
int _1284850;
_1284850 = _1284829 * _1284832;
unsigned int _1284847;
_1284847 = bh_upper_1284846.e0;
int _1284853;
_1284853 = _1027208_1284809.e3;
int gid_y_1284851;
gid_y_1284851 = _1284826 + _1284850;
bool _1284848;
_1284848 = _1284847 == 0;
int _1284852;
_1284852 = 1 + gid_y_1284851;
int _1284854;
_1284854 = _1284852 * _1284853;
if (_1284848) goto l1284849; else goto l1284994;
l1284994: ;
bool _1284995;
_1284995 = _1284847 == 1;
if (_1284995) goto l1284996; else goto l1284998;
l1284998: ;
// bottom: float r4_1265918_2202;
// bottom: p_1284864 = r4_1265918_2202;
goto l1284862;
l1284996: ;
float c_1284997;
c_1284997 = _1284855.pf32;
p_1284864 = c_1284997;
goto l1284862;
l1284849: ;
int x_1284856;
x_1284856 = _1284855.qs32;
int _1284857;
_1284857 = _1284854 + x_1284856;
float* idx_1284858;
idx_1284858 = _1027211_1284812 + _1284857;
_1284861 = __ldg(idx_1284858);
p_1284861 = _1284861;
l1284859: ;
_1284861 = p_1284861;
p_1284864 = _1284861;
goto l1284862;
l1284862: ;
_1284864 = p_1284864;
int _1284945;
_1284945 = _1027213_1284814.e3;
int _1284946;
_1284946 = _1284852 * _1284945;
int _1284947;
_1284947 = _1284946 + gid_x_1284841;
float* idx_1284948;
idx_1284948 = _1027209_1284810 + _1284947;
float _1284949;
_1284949 = *idx_1284948;
if (_1284842) goto l1284865; else goto l1284993;
l1284993: ;
pbh_upper_1284868 = _1284970;
goto l1284866;
l1284865: ;
union variant_220130 _1265919_2204;
_1265919_2204.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2206;
_1265920_2206.e0 = 1;
_1265920_2206.e1 = _1265919_2204;
pbh_upper_1284868 = _1265920_2206;
goto l1284866;
l1284866: ;
bh_upper_1284868 = pbh_upper_1284868;
union variant_220130 _1284873;
_1284873 = bh_upper_1284868.e1;
unsigned int _1284869;
_1284869 = bh_upper_1284868.e0;
bool _1284870;
_1284870 = _1284869 == 0;
if (_1284870) goto l1284871; else goto l1284987;
l1284987: ;
bool _1284988;
_1284988 = _1284869 == 1;
if (_1284988) goto l1284989; else goto l1284991;
l1284991: ;
// bottom: float r4_1265918_2214;
// bottom: p_1284882 = r4_1265918_2214;
goto l1284880;
l1284989: ;
float c_1284990;
c_1284990 = _1284873.pf32;
p_1284882 = c_1284990;
goto l1284880;
l1284871: ;
int x_1284874;
x_1284874 = _1284873.qs32;
int _1284872;
_1284872 = gid_y_1284851 * _1284853;
int _1284875;
_1284875 = _1284872 + x_1284874;
float* idx_1284876;
idx_1284876 = _1027211_1284812 + _1284875;
_1284879 = __ldg(idx_1284876);
p_1284879 = _1284879;
l1284877: ;
_1284879 = p_1284879;
p_1284882 = _1284879;
goto l1284880;
l1284880: ;
_1284882 = p_1284882;
int _1284883;
_1284883 = -1 + gid_x_1284841;
bool _1284884;
_1284884 = _1284836 <= _1284883;
if (_1284884) goto l1284885; else goto l1284984;
l1284984: ;
union variant_220130 _1284985;
_1284985.qs32 = _1284883;
struct_BoundaryMode_220129 _1284986;
_1284986.e0 = 0;
_1284986.e1 = _1284985;
pbh_upper_1284888 = _1284986;
goto l1284886;
l1284885: ;
union variant_220130 _1265919_2219;
_1265919_2219.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2221;
_1265920_2221.e0 = 1;
_1265920_2221.e1 = _1265919_2219;
pbh_upper_1284888 = _1265920_2221;
goto l1284886;
l1284886: ;
bh_upper_1284888 = pbh_upper_1284888;
union variant_220130 _1284892;
_1284892 = bh_upper_1284888.e1;
unsigned int _1284889;
_1284889 = bh_upper_1284888.e0;
bool _1284890;
_1284890 = _1284889 == 0;
if (_1284890) goto l1284891; else goto l1284979;
l1284979: ;
bool _1284980;
_1284980 = _1284889 == 1;
if (_1284980) goto l1284981; else goto l1284983;
l1284983: ;
// bottom: float r4_1265918_2229;
// bottom: p_1284901 = r4_1265918_2229;
goto l1284899;
l1284981: ;
float c_1284982;
c_1284982 = _1284892.pf32;
p_1284901 = c_1284982;
goto l1284899;
l1284891: ;
int x_1284893;
x_1284893 = _1284892.qs32;
int _1284894;
_1284894 = _1284854 + x_1284893;
float* idx_1284895;
idx_1284895 = _1027211_1284812 + _1284894;
_1284898 = __ldg(idx_1284895);
p_1284898 = _1284898;
l1284896: ;
_1284898 = p_1284898;
p_1284901 = _1284898;
goto l1284899;
l1284899: ;
_1284901 = p_1284901;
int _1284902;
_1284902 = 1 + gid_x_1284841;
bool _1284903;
_1284903 = _1284836 <= _1284902;
if (_1284903) goto l1284904; else goto l1284976;
l1284976: ;
union variant_220130 _1284977;
_1284977.qs32 = _1284902;
struct_BoundaryMode_220129 _1284978;
_1284978.e0 = 0;
_1284978.e1 = _1284977;
pbh_upper_1284907 = _1284978;
goto l1284905;
l1284904: ;
union variant_220130 _1265919_2234;
_1265919_2234.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2236;
_1265920_2236.e0 = 1;
_1265920_2236.e1 = _1265919_2234;
pbh_upper_1284907 = _1265920_2236;
goto l1284905;
l1284905: ;
bh_upper_1284907 = pbh_upper_1284907;
union variant_220130 _1284911;
_1284911 = bh_upper_1284907.e1;
unsigned int _1284908;
_1284908 = bh_upper_1284907.e0;
bool _1284909;
_1284909 = _1284908 == 0;
if (_1284909) goto l1284910; else goto l1284971;
l1284971: ;
bool _1284972;
_1284972 = _1284908 == 1;
if (_1284972) goto l1284973; else goto l1284975;
l1284975: ;
// bottom: float r4_1265918_2244;
// bottom: p_1284920 = r4_1265918_2244;
goto l1284918;
l1284973: ;
float c_1284974;
c_1284974 = _1284911.pf32;
p_1284920 = c_1284974;
goto l1284918;
l1284910: ;
int x_1284912;
x_1284912 = _1284911.qs32;
int _1284913;
_1284913 = _1284854 + x_1284912;
float* idx_1284914;
idx_1284914 = _1027211_1284812 + _1284913;
_1284917 = __ldg(idx_1284914);
p_1284917 = _1284917;
l1284915: ;
_1284917 = p_1284917;
p_1284920 = _1284917;
goto l1284918;
l1284918: ;
_1284920 = p_1284920;
if (_1284842) goto l1284921; else goto l1284968;
l1284968: ;
pbh_upper_1284924 = _1284970;
goto l1284922;
l1284921: ;
union variant_220130 _1265919_2245;
_1265919_2245.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2247;
_1265920_2247.e0 = 1;
_1265920_2247.e1 = _1265919_2245;
pbh_upper_1284924 = _1265920_2247;
goto l1284922;
l1284922: ;
bh_upper_1284924 = pbh_upper_1284924;
union variant_220130 _1284930;
_1284930 = bh_upper_1284924.e1;
unsigned int _1284925;
_1284925 = bh_upper_1284924.e0;
bool _1284926;
_1284926 = _1284925 == 0;
if (_1284926) goto l1284927; else goto l1284963;
l1284963: ;
bool _1284964;
_1284964 = _1284925 == 1;
if (_1284964) goto l1284965; else goto l1284967;
l1284967: ;
// bottom: float r4_1265918_2255;
// bottom: p_1284939 = r4_1265918_2255;
goto l1284937;
l1284965: ;
float c_1284966;
c_1284966 = _1284930.pf32;
p_1284939 = c_1284966;
goto l1284937;
l1284927: ;
int _1284928;
_1284928 = 2 + gid_y_1284851;
int _1284929;
_1284929 = _1284928 * _1284853;
int x_1284931;
x_1284931 = _1284930.qs32;
int _1284932;
_1284932 = _1284929 + x_1284931;
float* idx_1284933;
idx_1284933 = _1027211_1284812 + _1284932;
_1284936 = __ldg(idx_1284933);
p_1284936 = _1284936;
l1284934: ;
_1284936 = p_1284936;
p_1284939 = _1284936;
goto l1284937;
l1284937: ;
_1284939 = p_1284939;
float _1284950;
_1284950 = _1284949;
float _1284957;
_1284957 = 2.500000e-01f * _1284920;
float _1284955;
_1284955 = 2.500000e-01f * _1284901;
float _1284953;
_1284953 = 2.500000e-01f * _1284882;
float _1284944;
_1284944 = 2.000000e-01f * _1284864;
float _1284951;
_1284951 = 2.000000e-01f * _1284950;
float _1284959;
_1284959 = 2.500000e-01f * _1284939;
float _1284954;
_1284954 = 0.000000e+00f + _1284953;
int _1284940;
_1284940 = _1027210_1284811.e3;
float _1284956;
_1284956 = _1284954 + _1284955;
float _1284952;
_1284952 = _1284944 + _1284951;
int _1284941;
_1284941 = _1284852 * _1284940;
float _1284958;
_1284958 = _1284956 + _1284957;
int _1284942;
_1284942 = _1284941 + gid_x_1284841;
float _1284960;
_1284960 = _1284958 + _1284959;
float* idx_1284943;
idx_1284943 = _1027212_1284813 + _1284942;
float val_1284961;
val_1284961 = _1284952 + _1284960;
*idx_1284943 = val_1284961;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1025365(struct_Img_220118 _1025368_1273598, float* _1025369_1273599, struct_Img_220118 _1025370_1273600, float* _1025371_1273601, float* _1025372_1273602, struct_Img_220118 _1025373_1273603) {
int _1273606;
int p_1273606;
int _1273609;
int p_1273609;
int _1273612;
int p_1273612;
int _1273615;
int p_1273615;
int _1273618;
int p_1273618;
int _1273621;
int p_1273621;
int _1273624;
int p_1273624;
struct_BoundaryMode_220129 bh_lower_1273631;
struct_BoundaryMode_220129 pbh_lower_1273631;
float _1273646;
float p_1273646;
float _1273649;
float p_1273649;
struct_BoundaryMode_220129 bh_lower_1273655;
struct_BoundaryMode_220129 pbh_lower_1273655;
float _1273667;
float p_1273667;
float _1273670;
float p_1273670;
struct_BoundaryMode_220129 bh_lower_1273674;
struct_BoundaryMode_220129 pbh_lower_1273674;
float _1273686;
float p_1273686;
float _1273689;
float p_1273689;
struct_BoundaryMode_220129 bh_lower_1273693;
struct_BoundaryMode_220129 pbh_lower_1273693;
float _1273705;
float p_1273705;
float _1273708;
float p_1273708;
struct_BoundaryMode_220129 bh_lower_1273714;
struct_BoundaryMode_220129 pbh_lower_1273714;
float _1273726;
float p_1273726;
float _1273729;
float p_1273729;
_1273606 = threadIdx_x();
p_1273606 = _1273606;
l1273604: ;
_1273606 = p_1273606;
_1273609 = blockDim_x();
p_1273609 = _1273609;
l1273607: ;
_1273609 = p_1273609;
_1273612 = blockIdx_x();
p_1273612 = _1273612;
l1273610: ;
_1273612 = p_1273612;
_1273615 = threadIdx_y();
p_1273615 = _1273615;
l1273613: ;
_1273615 = p_1273615;
_1273618 = blockDim_y();
p_1273618 = _1273618;
l1273616: ;
_1273618 = p_1273618;
_1273621 = blockIdx_y();
p_1273621 = _1273621;
l1273619: ;
_1273621 = p_1273621;
_1273624 = blockDim_y();
p_1273624 = _1273624;
l1273622: ;
_1273624 = p_1273624;
int _1273625;
_1273625 = _1273618 * _1273621;
int gid_y_1273626;
gid_y_1273626 = _1273615 + _1273625;
union variant_220130 _1273769;
_1273769.qs32 = gid_y_1273626;
bool _1273627;
_1273627 = gid_y_1273626 < 0;
struct_BoundaryMode_220129 _1273770;
_1273770.e0 = 0;
_1273770.e1 = _1273769;
if (_1273627) goto l1273628; else goto l1273791;
l1273791: ;
pbh_lower_1273631 = _1273770;
goto l1273629;
l1273628: ;
union variant_220130 _1265919_2269;
_1265919_2269.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2271;
_1265920_2271.e0 = 1;
_1265920_2271.e1 = _1265919_2269;
pbh_lower_1273631 = _1265920_2271;
goto l1273629;
l1273629: ;
bh_lower_1273631 = pbh_lower_1273631;
union variant_220130 _1273635;
_1273635 = bh_lower_1273631.e1;
int _1273637;
_1273637 = _1025368_1273598.e3;
unsigned int _1273632;
_1273632 = bh_lower_1273631.e0;
int _1273639;
_1273639 = _1273609 * _1273612;
bool _1273633;
_1273633 = _1273632 == 0;
int gid_x_1273640;
gid_x_1273640 = _1273606 + _1273639;
if (_1273633) goto l1273634; else goto l1273786;
l1273786: ;
bool _1273787;
_1273787 = _1273632 == 1;
if (_1273787) goto l1273788; else goto l1273790;
l1273790: ;
// bottom: float r4_1265918_2280;
// bottom: p_1273649 = r4_1265918_2280;
goto l1273647;
l1273788: ;
float c_1273789;
c_1273789 = _1273635.pf32;
p_1273649 = c_1273789;
goto l1273647;
l1273634: ;
int y_1273636;
y_1273636 = _1273635.qs32;
int _1273638;
_1273638 = y_1273636 * _1273637;
int _1273641;
_1273641 = _1273638 + gid_x_1273640;
int _1273642;
_1273642 = 128 + _1273641;
float* idx_1273643;
idx_1273643 = _1025371_1273601 + _1273642;
_1273646 = __ldg(idx_1273643);
p_1273646 = _1273646;
l1273644: ;
_1273646 = p_1273646;
p_1273649 = _1273646;
goto l1273647;
l1273647: ;
_1273649 = p_1273649;
int _1273650;
_1273650 = -1 + gid_y_1273626;
bool _1273651;
_1273651 = _1273650 < 0;
int _1273736;
_1273736 = _1025373_1273603.e3;
int _1273737;
_1273737 = gid_y_1273626 * _1273736;
int _1273738;
_1273738 = _1273737 + gid_x_1273640;
int _1273739;
_1273739 = 128 + _1273738;
float* idx_1273740;
idx_1273740 = _1025369_1273599 + _1273739;
float _1273741;
_1273741 = *idx_1273740;
if (_1273651) goto l1273652; else goto l1273783;
l1273783: ;
union variant_220130 _1273784;
_1273784.qs32 = _1273650;
struct_BoundaryMode_220129 _1273785;
_1273785.e0 = 0;
_1273785.e1 = _1273784;
pbh_lower_1273655 = _1273785;
goto l1273653;
l1273652: ;
union variant_220130 _1265919_2289;
_1265919_2289.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2291;
_1265920_2291.e0 = 1;
_1265920_2291.e1 = _1265919_2289;
pbh_lower_1273655 = _1265920_2291;
goto l1273653;
l1273653: ;
bh_lower_1273655 = pbh_lower_1273655;
union variant_220130 _1273659;
_1273659 = bh_lower_1273655.e1;
unsigned int _1273656;
_1273656 = bh_lower_1273655.e0;
bool _1273657;
_1273657 = _1273656 == 0;
if (_1273657) goto l1273658; else goto l1273777;
l1273777: ;
bool _1273778;
_1273778 = _1273656 == 1;
if (_1273778) goto l1273779; else goto l1273781;
l1273781: ;
// bottom: float r4_1265918_2299;
// bottom: p_1273670 = r4_1265918_2299;
goto l1273668;
l1273779: ;
float c_1273780;
c_1273780 = _1273659.pf32;
p_1273670 = c_1273780;
goto l1273668;
l1273658: ;
int y_1273660;
y_1273660 = _1273659.qs32;
int _1273661;
_1273661 = y_1273660 * _1273637;
int _1273662;
_1273662 = _1273661 + gid_x_1273640;
int _1273663;
_1273663 = 128 + _1273662;
float* idx_1273664;
idx_1273664 = _1025371_1273601 + _1273663;
_1273667 = __ldg(idx_1273664);
p_1273667 = _1273667;
l1273665: ;
_1273667 = p_1273667;
p_1273670 = _1273667;
goto l1273668;
l1273668: ;
_1273670 = p_1273670;
if (_1273627) goto l1273671; else goto l1273776;
l1273776: ;
pbh_lower_1273674 = _1273770;
goto l1273672;
l1273671: ;
union variant_220130 _1265919_2301;
_1265919_2301.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2303;
_1265920_2303.e0 = 1;
_1265920_2303.e1 = _1265919_2301;
pbh_lower_1273674 = _1265920_2303;
goto l1273672;
l1273672: ;
bh_lower_1273674 = pbh_lower_1273674;
unsigned int _1273675;
_1273675 = bh_lower_1273674.e0;
union variant_220130 _1273678;
_1273678 = bh_lower_1273674.e1;
bool _1273676;
_1273676 = _1273675 == 0;
if (_1273676) goto l1273677; else goto l1273771;
l1273771: ;
bool _1273772;
_1273772 = _1273675 == 1;
if (_1273772) goto l1273773; else goto l1273775;
l1273775: ;
// bottom: float r4_1265918_2311;
// bottom: p_1273689 = r4_1265918_2311;
goto l1273687;
l1273773: ;
float c_1273774;
c_1273774 = _1273678.pf32;
p_1273689 = c_1273774;
goto l1273687;
l1273677: ;
int y_1273679;
y_1273679 = _1273678.qs32;
int _1273680;
_1273680 = y_1273679 * _1273637;
int _1273681;
_1273681 = _1273680 + gid_x_1273640;
int _1273682;
_1273682 = 127 + _1273681;
float* idx_1273683;
idx_1273683 = _1025371_1273601 + _1273682;
_1273686 = __ldg(idx_1273683);
p_1273686 = _1273686;
l1273684: ;
_1273686 = p_1273686;
p_1273689 = _1273686;
goto l1273687;
l1273687: ;
_1273689 = p_1273689;
if (_1273627) goto l1273690; else goto l1273768;
l1273768: ;
pbh_lower_1273693 = _1273770;
goto l1273691;
l1273690: ;
union variant_220130 _1265919_2313;
_1265919_2313.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2315;
_1265920_2315.e0 = 1;
_1265920_2315.e1 = _1265919_2313;
pbh_lower_1273693 = _1265920_2315;
goto l1273691;
l1273691: ;
bh_lower_1273693 = pbh_lower_1273693;
union variant_220130 _1273697;
_1273697 = bh_lower_1273693.e1;
unsigned int _1273694;
_1273694 = bh_lower_1273693.e0;
bool _1273695;
_1273695 = _1273694 == 0;
if (_1273695) goto l1273696; else goto l1273763;
l1273763: ;
bool _1273764;
_1273764 = _1273694 == 1;
if (_1273764) goto l1273765; else goto l1273767;
l1273767: ;
// bottom: float r4_1265918_2323;
// bottom: p_1273708 = r4_1265918_2323;
goto l1273706;
l1273765: ;
float c_1273766;
c_1273766 = _1273697.pf32;
p_1273708 = c_1273766;
goto l1273706;
l1273696: ;
int y_1273698;
y_1273698 = _1273697.qs32;
int _1273699;
_1273699 = y_1273698 * _1273637;
int _1273700;
_1273700 = _1273699 + gid_x_1273640;
int _1273701;
_1273701 = 129 + _1273700;
float* idx_1273702;
idx_1273702 = _1025371_1273601 + _1273701;
_1273705 = __ldg(idx_1273702);
p_1273705 = _1273705;
l1273703: ;
_1273705 = p_1273705;
p_1273708 = _1273705;
goto l1273706;
l1273706: ;
_1273708 = p_1273708;
int _1273709;
_1273709 = 1 + gid_y_1273626;
bool _1273710;
_1273710 = _1273709 < 0;
if (_1273710) goto l1273711; else goto l1273760;
l1273760: ;
union variant_220130 _1273761;
_1273761.qs32 = _1273709;
struct_BoundaryMode_220129 _1273762;
_1273762.e0 = 0;
_1273762.e1 = _1273761;
pbh_lower_1273714 = _1273762;
goto l1273712;
l1273711: ;
union variant_220130 _1265919_2330;
_1265919_2330.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2332;
_1265920_2332.e0 = 1;
_1265920_2332.e1 = _1265919_2330;
pbh_lower_1273714 = _1265920_2332;
goto l1273712;
l1273712: ;
bh_lower_1273714 = pbh_lower_1273714;
unsigned int _1273715;
_1273715 = bh_lower_1273714.e0;
bool _1273716;
_1273716 = _1273715 == 0;
union variant_220130 _1273718;
_1273718 = bh_lower_1273714.e1;
if (_1273716) goto l1273717; else goto l1273755;
l1273755: ;
bool _1273756;
_1273756 = _1273715 == 1;
if (_1273756) goto l1273757; else goto l1273759;
l1273759: ;
// bottom: float r4_1265918_2340;
// bottom: p_1273729 = r4_1265918_2340;
goto l1273727;
l1273757: ;
float c_1273758;
c_1273758 = _1273718.pf32;
p_1273729 = c_1273758;
goto l1273727;
l1273717: ;
int y_1273719;
y_1273719 = _1273718.qs32;
int _1273720;
_1273720 = y_1273719 * _1273637;
int _1273721;
_1273721 = _1273720 + gid_x_1273640;
int _1273722;
_1273722 = 128 + _1273721;
float* idx_1273723;
idx_1273723 = _1025371_1273601 + _1273722;
_1273726 = __ldg(idx_1273723);
p_1273726 = _1273726;
l1273724: ;
_1273726 = p_1273726;
p_1273729 = _1273726;
goto l1273727;
l1273727: ;
_1273729 = p_1273729;
float _1273749;
_1273749 = 2.500000e-01f * _1273708;
float _1273742;
_1273742 = _1273741;
float _1273751;
_1273751 = 2.500000e-01f * _1273729;
float _1273745;
_1273745 = 2.500000e-01f * _1273670;
float _1273735;
_1273735 = 2.000000e-01f * _1273649;
float _1273747;
_1273747 = 2.500000e-01f * _1273689;
int _1273730;
_1273730 = _1025370_1273600.e3;
float _1273743;
_1273743 = 2.000000e-01f * _1273742;
float _1273746;
_1273746 = 0.000000e+00f + _1273745;
float _1273744;
_1273744 = _1273735 + _1273743;
float _1273748;
_1273748 = _1273746 + _1273747;
int _1273731;
_1273731 = gid_y_1273626 * _1273730;
float _1273750;
_1273750 = _1273748 + _1273749;
int _1273732;
_1273732 = _1273731 + gid_x_1273640;
float _1273752;
_1273752 = _1273750 + _1273751;
int _1273733;
_1273733 = 128 + _1273732;
float val_1273753;
val_1273753 = _1273744 + _1273752;
float* idx_1273734;
idx_1273734 = _1025372_1273602 + _1273733;
*idx_1273734 = val_1273753;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1041691(struct_Img_220118 _1041694_1267572, struct_Img_220118 _1041695_1267573, float* _1041696_1267574, struct_Img_220118 _1041697_1267575, float* _1041698_1267576, float* _1041699_1267577) {
int _1267580;
int p_1267580;
int _1267583;
int p_1267583;
int _1267586;
int p_1267586;
int _1267589;
int p_1267589;
int _1267592;
int p_1267592;
int _1267595;
int p_1267595;
int _1267598;
int p_1267598;
struct_BoundaryMode_220129 bh_upper_1267609;
struct_BoundaryMode_220129 pbh_upper_1267609;
struct_BoundaryMode_220129 bh_upper_1267620;
struct_BoundaryMode_220129 pbh_upper_1267620;
float _1267637;
float p_1267637;
float _1267640;
float p_1267640;
struct_BoundaryMode_220129 bh_upper_1267644;
struct_BoundaryMode_220129 pbh_upper_1267644;
struct_BoundaryMode_220129 bh_upper_1267650;
struct_BoundaryMode_220129 pbh_upper_1267650;
float _1267666;
float p_1267666;
float _1267669;
float p_1267669;
struct_BoundaryMode_220129 bh_upper_1267675;
struct_BoundaryMode_220129 pbh_upper_1267675;
struct_BoundaryMode_220129 bh_upper_1267679;
struct_BoundaryMode_220129 pbh_upper_1267679;
float _1267695;
float p_1267695;
float _1267698;
float p_1267698;
struct_BoundaryMode_220129 bh_upper_1267704;
struct_BoundaryMode_220129 pbh_upper_1267704;
struct_BoundaryMode_220129 bh_upper_1267708;
struct_BoundaryMode_220129 pbh_upper_1267708;
float _1267724;
float p_1267724;
float _1267727;
float p_1267727;
struct_BoundaryMode_220129 bh_upper_1267731;
struct_BoundaryMode_220129 pbh_upper_1267731;
struct_BoundaryMode_220129 bh_upper_1267737;
struct_BoundaryMode_220129 pbh_upper_1267737;
float _1267753;
float p_1267753;
float _1267756;
float p_1267756;
_1267580 = threadIdx_x();
p_1267580 = _1267580;
l1267578: ;
_1267580 = p_1267580;
_1267583 = blockDim_x();
p_1267583 = _1267583;
l1267581: ;
_1267583 = p_1267583;
_1267586 = blockIdx_x();
p_1267586 = _1267586;
l1267584: ;
_1267586 = p_1267586;
_1267589 = threadIdx_y();
p_1267589 = _1267589;
l1267587: ;
_1267589 = p_1267589;
_1267592 = blockDim_y();
p_1267592 = _1267592;
l1267590: ;
_1267592 = p_1267592;
_1267595 = blockIdx_y();
p_1267595 = _1267595;
l1267593: ;
_1267595 = p_1267595;
_1267598 = blockDim_y();
p_1267598 = _1267598;
l1267596: ;
_1267598 = p_1267598;
int _1267600;
_1267600 = _1041695_1267573.e1;
int _1267601;
_1267601 = _1267600 - 128;
int _1267599;
_1267599 = _1041694_1267572.e1;
int _1267602;
_1267602 = _1267601 + _1267580;
int _1267603;
_1267603 = _1267583 * _1267586;
int gid_x_1267604;
gid_x_1267604 = _1267602 + _1267603;
bool _1267605;
_1267605 = _1267599 <= gid_x_1267604;
union variant_220130 _1267793;
_1267793.qs32 = gid_x_1267604;
struct_BoundaryMode_220129 _1267794;
_1267794.e0 = 0;
_1267794.e1 = _1267793;
if (_1267605) goto l1267606; else goto l1267847;
l1267847: ;
pbh_upper_1267609 = _1267794;
goto l1267607;
l1267606: ;
union variant_220130 _1265919_2357;
_1265919_2357.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2359;
_1265920_2359.e0 = 1;
_1265920_2359.e1 = _1265919_2357;
pbh_upper_1267609 = _1265920_2359;
goto l1267607;
l1267607: ;
bh_upper_1267609 = pbh_upper_1267609;
int _1267610;
_1267610 = _1041694_1267572.e2;
int _1267614;
_1267614 = _1267592 * _1267595;
int _1267611;
_1267611 = _1041695_1267573.e2;
int _1267612;
_1267612 = _1267611 - 1;
int _1267613;
_1267613 = _1267612 + _1267589;
int gid_y_1267615;
gid_y_1267615 = _1267613 + _1267614;
bool _1267616;
_1267616 = _1267610 <= gid_y_1267615;
union variant_220130 _1267805;
_1267805.qs32 = gid_y_1267615;
struct_BoundaryMode_220129 _1267806;
_1267806.e0 = 0;
_1267806.e1 = _1267805;
if (_1267616) goto l1267617; else goto l1267846;
l1267846: ;
pbh_upper_1267620 = _1267806;
goto l1267618;
l1267617: ;
union variant_220130 _1265919_2369;
_1265919_2369.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2371;
_1265920_2371.e0 = 1;
_1265920_2371.e1 = _1265919_2369;
pbh_upper_1267620 = _1265920_2371;
goto l1267618;
l1267618: ;
bh_upper_1267620 = pbh_upper_1267620;
unsigned int _1267623;
_1267623 = bh_upper_1267620.e0;
int _1267629;
_1267629 = _1041694_1267572.e3;
unsigned int _1267621;
_1267621 = bh_upper_1267609.e0;
bool _1267622;
_1267622 = _1267621 == 0;
union variant_220130 _1267631;
_1267631 = bh_upper_1267609.e1;
union variant_220130 _1267627;
_1267627 = bh_upper_1267620.e1;
bool _1267624;
_1267624 = _1267623 == 0;
bool _1267625;
_1267625 = _1267622 & _1267624;
if (_1267625) goto l1267626; else goto l1267837;
l1267837: ;
bool _1267838;
_1267838 = _1267621 == 1;
if (_1267838) goto l1267839; else goto l1267841;
l1267841: ;
bool _1267842;
_1267842 = _1267623 == 1;
if (_1267842) goto l1267843; else goto l1267845;
l1267845: ;
// bottom: float r4_1265918_2384;
// bottom: p_1267640 = r4_1265918_2384;
goto l1267638;
l1267843: ;
float c_1267844;
c_1267844 = _1267627.pf32;
p_1267640 = c_1267844;
goto l1267638;
l1267839: ;
float c_1267840;
c_1267840 = _1267631.pf32;
p_1267640 = c_1267840;
goto l1267638;
l1267626: ;
int x_1267632;
x_1267632 = _1267631.qs32;
int y_1267628;
y_1267628 = _1267627.qs32;
int _1267630;
_1267630 = y_1267628 * _1267629;
int _1267633;
_1267633 = _1267630 + x_1267632;
float* idx_1267634;
idx_1267634 = _1041696_1267574 + _1267633;
_1267637 = __ldg(idx_1267634);
p_1267637 = _1267637;
l1267635: ;
_1267637 = p_1267637;
p_1267640 = _1267637;
goto l1267638;
l1267638: ;
_1267640 = p_1267640;
int _1267762;
_1267762 = _1041697_1267575.e3;
int _1267763;
_1267763 = gid_y_1267615 * _1267762;
int _1267764;
_1267764 = _1267763 + gid_x_1267604;
float* idx_1267765;
idx_1267765 = _1041699_1267577 + _1267764;
float _1267766;
_1267766 = *idx_1267765;
if (_1267605) goto l1267641; else goto l1267836;
l1267836: ;
pbh_upper_1267644 = _1267794;
goto l1267642;
l1267641: ;
union variant_220130 _1265919_2386;
_1265919_2386.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2388;
_1265920_2388.e0 = 1;
_1265920_2388.e1 = _1265919_2386;
pbh_upper_1267644 = _1265920_2388;
goto l1267642;
l1267642: ;
bh_upper_1267644 = pbh_upper_1267644;
int _1267645;
_1267645 = -1 + gid_y_1267615;
bool _1267646;
_1267646 = _1267610 <= _1267645;
if (_1267646) goto l1267647; else goto l1267832;
l1267832: ;
union variant_220130 _1267833;
_1267833.qs32 = _1267645;
struct_BoundaryMode_220129 _1267834;
_1267834.e0 = 0;
_1267834.e1 = _1267833;
pbh_upper_1267650 = _1267834;
goto l1267648;
l1267647: ;
union variant_220130 _1265919_2396;
_1265919_2396.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2398;
_1265920_2398.e0 = 1;
_1265920_2398.e1 = _1265919_2396;
pbh_upper_1267650 = _1265920_2398;
goto l1267648;
l1267648: ;
bh_upper_1267650 = pbh_upper_1267650;
unsigned int _1267651;
_1267651 = bh_upper_1267644.e0;
union variant_220130 _1267657;
_1267657 = bh_upper_1267650.e1;
unsigned int _1267653;
_1267653 = bh_upper_1267650.e0;
union variant_220130 _1267660;
_1267660 = bh_upper_1267644.e1;
bool _1267654;
_1267654 = _1267653 == 0;
bool _1267652;
_1267652 = _1267651 == 0;
bool _1267655;
_1267655 = _1267652 & _1267654;
if (_1267655) goto l1267656; else goto l1267823;
l1267823: ;
bool _1267824;
_1267824 = _1267651 == 1;
if (_1267824) goto l1267825; else goto l1267827;
l1267827: ;
bool _1267828;
_1267828 = _1267653 == 1;
if (_1267828) goto l1267829; else goto l1267831;
l1267831: ;
// bottom: float r4_1265918_2410;
// bottom: p_1267669 = r4_1265918_2410;
goto l1267667;
l1267829: ;
float c_1267830;
c_1267830 = _1267657.pf32;
p_1267669 = c_1267830;
goto l1267667;
l1267825: ;
float c_1267826;
c_1267826 = _1267660.pf32;
p_1267669 = c_1267826;
goto l1267667;
l1267656: ;
int x_1267661;
x_1267661 = _1267660.qs32;
int y_1267658;
y_1267658 = _1267657.qs32;
int _1267659;
_1267659 = y_1267658 * _1267629;
int _1267662;
_1267662 = _1267659 + x_1267661;
float* idx_1267663;
idx_1267663 = _1041696_1267574 + _1267662;
_1267666 = __ldg(idx_1267663);
p_1267666 = _1267666;
l1267664: ;
_1267666 = p_1267666;
p_1267669 = _1267666;
goto l1267667;
l1267667: ;
_1267669 = p_1267669;
int _1267670;
_1267670 = -1 + gid_x_1267604;
bool _1267671;
_1267671 = _1267599 <= _1267670;
if (_1267671) goto l1267672; else goto l1267820;
l1267820: ;
union variant_220130 _1267821;
_1267821.qs32 = _1267670;
struct_BoundaryMode_220129 _1267822;
_1267822.e0 = 0;
_1267822.e1 = _1267821;
pbh_upper_1267675 = _1267822;
goto l1267673;
l1267672: ;
union variant_220130 _1265919_2415;
_1265919_2415.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2417;
_1265920_2417.e0 = 1;
_1265920_2417.e1 = _1265919_2415;
pbh_upper_1267675 = _1265920_2417;
goto l1267673;
l1267673: ;
bh_upper_1267675 = pbh_upper_1267675;
if (_1267616) goto l1267676; else goto l1267819;
l1267819: ;
pbh_upper_1267679 = _1267806;
goto l1267677;
l1267676: ;
union variant_220130 _1265919_2421;
_1265919_2421.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2423;
_1265920_2423.e0 = 1;
_1265920_2423.e1 = _1265919_2421;
pbh_upper_1267679 = _1265920_2423;
goto l1267677;
l1267677: ;
bh_upper_1267679 = pbh_upper_1267679;
union variant_220130 _1267686;
_1267686 = bh_upper_1267679.e1;
unsigned int _1267680;
_1267680 = bh_upper_1267675.e0;
unsigned int _1267682;
_1267682 = bh_upper_1267679.e0;
union variant_220130 _1267689;
_1267689 = bh_upper_1267675.e1;
bool _1267681;
_1267681 = _1267680 == 0;
bool _1267683;
_1267683 = _1267682 == 0;
bool _1267684;
_1267684 = _1267681 & _1267683;
if (_1267684) goto l1267685; else goto l1267810;
l1267810: ;
bool _1267811;
_1267811 = _1267680 == 1;
if (_1267811) goto l1267812; else goto l1267814;
l1267814: ;
bool _1267815;
_1267815 = _1267682 == 1;
if (_1267815) goto l1267816; else goto l1267818;
l1267818: ;
// bottom: float r4_1265918_2435;
// bottom: p_1267698 = r4_1265918_2435;
goto l1267696;
l1267816: ;
float c_1267817;
c_1267817 = _1267686.pf32;
p_1267698 = c_1267817;
goto l1267696;
l1267812: ;
float c_1267813;
c_1267813 = _1267689.pf32;
p_1267698 = c_1267813;
goto l1267696;
l1267685: ;
int y_1267687;
y_1267687 = _1267686.qs32;
int x_1267690;
x_1267690 = _1267689.qs32;
int _1267688;
_1267688 = y_1267687 * _1267629;
int _1267691;
_1267691 = _1267688 + x_1267690;
float* idx_1267692;
idx_1267692 = _1041696_1267574 + _1267691;
_1267695 = __ldg(idx_1267692);
p_1267695 = _1267695;
l1267693: ;
_1267695 = p_1267695;
p_1267698 = _1267695;
goto l1267696;
l1267696: ;
_1267698 = p_1267698;
int _1267699;
_1267699 = 1 + gid_x_1267604;
bool _1267700;
_1267700 = _1267599 <= _1267699;
if (_1267700) goto l1267701; else goto l1267807;
l1267807: ;
union variant_220130 _1267808;
_1267808.qs32 = _1267699;
struct_BoundaryMode_220129 _1267809;
_1267809.e0 = 0;
_1267809.e1 = _1267808;
pbh_upper_1267704 = _1267809;
goto l1267702;
l1267701: ;
union variant_220130 _1265919_2440;
_1265919_2440.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2442;
_1265920_2442.e0 = 1;
_1265920_2442.e1 = _1265919_2440;
pbh_upper_1267704 = _1265920_2442;
goto l1267702;
l1267702: ;
bh_upper_1267704 = pbh_upper_1267704;
if (_1267616) goto l1267705; else goto l1267804;
l1267804: ;
pbh_upper_1267708 = _1267806;
goto l1267706;
l1267705: ;
union variant_220130 _1265919_2446;
_1265919_2446.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2448;
_1265920_2448.e0 = 1;
_1265920_2448.e1 = _1265919_2446;
pbh_upper_1267708 = _1265920_2448;
goto l1267706;
l1267706: ;
bh_upper_1267708 = pbh_upper_1267708;
union variant_220130 _1267715;
_1267715 = bh_upper_1267708.e1;
union variant_220130 _1267718;
_1267718 = bh_upper_1267704.e1;
unsigned int _1267711;
_1267711 = bh_upper_1267708.e0;
unsigned int _1267709;
_1267709 = bh_upper_1267704.e0;
bool _1267712;
_1267712 = _1267711 == 0;
bool _1267710;
_1267710 = _1267709 == 0;
bool _1267713;
_1267713 = _1267710 & _1267712;
if (_1267713) goto l1267714; else goto l1267795;
l1267795: ;
bool _1267796;
_1267796 = _1267709 == 1;
if (_1267796) goto l1267797; else goto l1267799;
l1267799: ;
bool _1267800;
_1267800 = _1267711 == 1;
if (_1267800) goto l1267801; else goto l1267803;
l1267803: ;
// bottom: float r4_1265918_2460;
// bottom: p_1267727 = r4_1265918_2460;
goto l1267725;
l1267801: ;
float c_1267802;
c_1267802 = _1267715.pf32;
p_1267727 = c_1267802;
goto l1267725;
l1267797: ;
float c_1267798;
c_1267798 = _1267718.pf32;
p_1267727 = c_1267798;
goto l1267725;
l1267714: ;
int y_1267716;
y_1267716 = _1267715.qs32;
int x_1267719;
x_1267719 = _1267718.qs32;
int _1267717;
_1267717 = y_1267716 * _1267629;
int _1267720;
_1267720 = _1267717 + x_1267719;
float* idx_1267721;
idx_1267721 = _1041696_1267574 + _1267720;
_1267724 = __ldg(idx_1267721);
p_1267724 = _1267724;
l1267722: ;
_1267724 = p_1267724;
p_1267727 = _1267724;
goto l1267725;
l1267725: ;
_1267727 = p_1267727;
if (_1267605) goto l1267728; else goto l1267792;
l1267792: ;
pbh_upper_1267731 = _1267794;
goto l1267729;
l1267728: ;
union variant_220130 _1265919_2461;
_1265919_2461.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2463;
_1265920_2463.e0 = 1;
_1265920_2463.e1 = _1265919_2461;
pbh_upper_1267731 = _1265920_2463;
goto l1267729;
l1267729: ;
bh_upper_1267731 = pbh_upper_1267731;
int _1267732;
_1267732 = 1 + gid_y_1267615;
bool _1267733;
_1267733 = _1267610 <= _1267732;
if (_1267733) goto l1267734; else goto l1267789;
l1267789: ;
union variant_220130 _1267790;
_1267790.qs32 = _1267732;
struct_BoundaryMode_220129 _1267791;
_1267791.e0 = 0;
_1267791.e1 = _1267790;
pbh_upper_1267737 = _1267791;
goto l1267735;
l1267734: ;
union variant_220130 _1265919_2471;
_1265919_2471.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2473;
_1265920_2473.e0 = 1;
_1265920_2473.e1 = _1265919_2471;
pbh_upper_1267737 = _1265920_2473;
goto l1267735;
l1267735: ;
bh_upper_1267737 = pbh_upper_1267737;
unsigned int _1267740;
_1267740 = bh_upper_1267737.e0;
unsigned int _1267738;
_1267738 = bh_upper_1267731.e0;
union variant_220130 _1267744;
_1267744 = bh_upper_1267737.e1;
union variant_220130 _1267747;
_1267747 = bh_upper_1267731.e1;
bool _1267739;
_1267739 = _1267738 == 0;
bool _1267741;
_1267741 = _1267740 == 0;
bool _1267742;
_1267742 = _1267739 & _1267741;
if (_1267742) goto l1267743; else goto l1267780;
l1267780: ;
bool _1267781;
_1267781 = _1267738 == 1;
if (_1267781) goto l1267782; else goto l1267784;
l1267784: ;
bool _1267785;
_1267785 = _1267740 == 1;
if (_1267785) goto l1267786; else goto l1267788;
l1267788: ;
// bottom: float r4_1265918_2485;
// bottom: p_1267756 = r4_1265918_2485;
goto l1267754;
l1267786: ;
float c_1267787;
c_1267787 = _1267744.pf32;
p_1267756 = c_1267787;
goto l1267754;
l1267782: ;
float c_1267783;
c_1267783 = _1267747.pf32;
p_1267756 = c_1267783;
goto l1267754;
l1267743: ;
int x_1267748;
x_1267748 = _1267747.qs32;
int y_1267745;
y_1267745 = _1267744.qs32;
int _1267746;
_1267746 = y_1267745 * _1267629;
int _1267749;
_1267749 = _1267746 + x_1267748;
float* idx_1267750;
idx_1267750 = _1041696_1267574 + _1267749;
_1267753 = __ldg(idx_1267750);
p_1267753 = _1267753;
l1267751: ;
_1267753 = p_1267753;
p_1267756 = _1267753;
goto l1267754;
l1267754: ;
_1267756 = p_1267756;
float _1267774;
_1267774 = 2.500000e-01f * _1267727;
float _1267770;
_1267770 = 2.500000e-01f * _1267669;
float _1267761;
_1267761 = 2.000000e-01f * _1267640;
float _1267772;
_1267772 = 2.500000e-01f * _1267698;
int _1267757;
_1267757 = _1041695_1267573.e3;
float _1267767;
_1267767 = _1267766;
float _1267776;
_1267776 = 2.500000e-01f * _1267756;
float _1267771;
_1267771 = 0.000000e+00f + _1267770;
float _1267773;
_1267773 = _1267771 + _1267772;
int _1267758;
_1267758 = gid_y_1267615 * _1267757;
float _1267768;
_1267768 = 2.000000e-01f * _1267767;
float _1267775;
_1267775 = _1267773 + _1267774;
int _1267759;
_1267759 = _1267758 + gid_x_1267604;
float _1267769;
_1267769 = _1267761 + _1267768;
float _1267777;
_1267777 = _1267775 + _1267776;
float* idx_1267760;
idx_1267760 = _1041698_1267576 + _1267759;
float val_1267778;
val_1267778 = _1267769 + _1267777;
*idx_1267760 = val_1267778;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1045126(float* _1045129_1279738, struct_Img_220118 _1045130_1279739, struct_Img_220118 _1045131_1279740, float* _1045132_1279741, struct_Img_220118 _1045133_1279742, float* _1045134_1279743) {
int _1279746;
int p_1279746;
int _1279749;
int p_1279749;
int _1279752;
int p_1279752;
int _1279755;
int p_1279755;
int _1279758;
int p_1279758;
int _1279761;
int p_1279761;
int _1279764;
int p_1279764;
struct_BoundaryMode_220129 bh_upper_1279775;
struct_BoundaryMode_220129 pbh_upper_1279775;
struct_BoundaryMode_220129 bh_lower_1279782;
struct_BoundaryMode_220129 pbh_lower_1279782;
float _1279799;
float p_1279799;
float _1279802;
float p_1279802;
struct_BoundaryMode_220129 bh_upper_1279806;
struct_BoundaryMode_220129 pbh_upper_1279806;
struct_BoundaryMode_220129 bh_lower_1279812;
struct_BoundaryMode_220129 pbh_lower_1279812;
float _1279828;
float p_1279828;
float _1279831;
float p_1279831;
struct_BoundaryMode_220129 bh_upper_1279837;
struct_BoundaryMode_220129 pbh_upper_1279837;
struct_BoundaryMode_220129 bh_lower_1279841;
struct_BoundaryMode_220129 pbh_lower_1279841;
float _1279857;
float p_1279857;
float _1279860;
float p_1279860;
struct_BoundaryMode_220129 bh_upper_1279866;
struct_BoundaryMode_220129 pbh_upper_1279866;
struct_BoundaryMode_220129 bh_lower_1279870;
struct_BoundaryMode_220129 pbh_lower_1279870;
float _1279886;
float p_1279886;
float _1279889;
float p_1279889;
struct_BoundaryMode_220129 bh_upper_1279893;
struct_BoundaryMode_220129 pbh_upper_1279893;
struct_BoundaryMode_220129 bh_lower_1279899;
struct_BoundaryMode_220129 pbh_lower_1279899;
float _1279915;
float p_1279915;
float _1279918;
float p_1279918;
_1279746 = threadIdx_x();
p_1279746 = _1279746;
l1279744: ;
_1279746 = p_1279746;
_1279749 = blockDim_x();
p_1279749 = _1279749;
l1279747: ;
_1279749 = p_1279749;
_1279752 = blockIdx_x();
p_1279752 = _1279752;
l1279750: ;
_1279752 = p_1279752;
_1279755 = threadIdx_y();
p_1279755 = _1279755;
l1279753: ;
_1279755 = p_1279755;
_1279758 = blockDim_y();
p_1279758 = _1279758;
l1279756: ;
_1279758 = p_1279758;
_1279761 = blockIdx_y();
p_1279761 = _1279761;
l1279759: ;
_1279761 = p_1279761;
_1279764 = blockDim_y();
p_1279764 = _1279764;
l1279762: ;
_1279764 = p_1279764;
int _1279765;
_1279765 = _1045130_1279739.e1;
int _1279769;
_1279769 = _1279749 * _1279752;
int _1279766;
_1279766 = _1045133_1279742.e1;
int _1279767;
_1279767 = _1279766 - 128;
int _1279768;
_1279768 = _1279767 + _1279746;
int gid_x_1279770;
gid_x_1279770 = _1279768 + _1279769;
bool _1279771;
_1279771 = _1279765 <= gid_x_1279770;
union variant_220130 _1279955;
_1279955.qs32 = gid_x_1279770;
struct_BoundaryMode_220129 _1279956;
_1279956.e0 = 0;
_1279956.e1 = _1279955;
if (_1279771) goto l1279772; else goto l1280009;
l1280009: ;
pbh_upper_1279775 = _1279956;
goto l1279773;
l1279772: ;
union variant_220130 _1265919_2500;
_1265919_2500.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2502;
_1265920_2502.e0 = 1;
_1265920_2502.e1 = _1265919_2500;
pbh_upper_1279775 = _1265920_2502;
goto l1279773;
l1279773: ;
bh_upper_1279775 = pbh_upper_1279775;
int _1279776;
_1279776 = _1279758 * _1279761;
int gid_y_1279777;
gid_y_1279777 = _1279755 + _1279776;
bool _1279778;
_1279778 = gid_y_1279777 < 0;
union variant_220130 _1279967;
_1279967.qs32 = gid_y_1279777;
struct_BoundaryMode_220129 _1279968;
_1279968.e0 = 0;
_1279968.e1 = _1279967;
if (_1279778) goto l1279779; else goto l1280008;
l1280008: ;
pbh_lower_1279782 = _1279968;
goto l1279780;
l1279779: ;
union variant_220130 _1265919_2510;
_1265919_2510.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2512;
_1265920_2512.e0 = 1;
_1265920_2512.e1 = _1265919_2510;
pbh_lower_1279782 = _1265920_2512;
goto l1279780;
l1279780: ;
bh_lower_1279782 = pbh_lower_1279782;
unsigned int _1279783;
_1279783 = bh_upper_1279775.e0;
bool _1279784;
_1279784 = _1279783 == 0;
union variant_220130 _1279789;
_1279789 = bh_lower_1279782.e1;
int _1279791;
_1279791 = _1045130_1279739.e3;
unsigned int _1279785;
_1279785 = bh_lower_1279782.e0;
union variant_220130 _1279793;
_1279793 = bh_upper_1279775.e1;
bool _1279786;
_1279786 = _1279785 == 0;
bool _1279787;
_1279787 = _1279784 & _1279786;
if (_1279787) goto l1279788; else goto l1279999;
l1279999: ;
bool _1280000;
_1280000 = _1279783 == 1;
if (_1280000) goto l1280001; else goto l1280003;
l1280003: ;
bool _1280004;
_1280004 = _1279785 == 1;
if (_1280004) goto l1280005; else goto l1280007;
l1280007: ;
// bottom: float r4_1265918_2525;
// bottom: p_1279802 = r4_1265918_2525;
goto l1279800;
l1280005: ;
float c_1280006;
c_1280006 = _1279789.pf32;
p_1279802 = c_1280006;
goto l1279800;
l1280001: ;
float c_1280002;
c_1280002 = _1279793.pf32;
p_1279802 = c_1280002;
goto l1279800;
l1279788: ;
int y_1279790;
y_1279790 = _1279789.qs32;
int x_1279794;
x_1279794 = _1279793.qs32;
int _1279792;
_1279792 = y_1279790 * _1279791;
int _1279795;
_1279795 = _1279792 + x_1279794;
float* idx_1279796;
idx_1279796 = _1045129_1279738 + _1279795;
_1279799 = __ldg(idx_1279796);
p_1279799 = _1279799;
l1279797: ;
_1279799 = p_1279799;
p_1279802 = _1279799;
goto l1279800;
l1279800: ;
_1279802 = p_1279802;
int _1279924;
_1279924 = _1045131_1279740.e3;
int _1279925;
_1279925 = gid_y_1279777 * _1279924;
int _1279926;
_1279926 = _1279925 + gid_x_1279770;
float* idx_1279927;
idx_1279927 = _1045134_1279743 + _1279926;
float _1279928;
_1279928 = *idx_1279927;
if (_1279771) goto l1279803; else goto l1279998;
l1279998: ;
pbh_upper_1279806 = _1279956;
goto l1279804;
l1279803: ;
union variant_220130 _1265919_2527;
_1265919_2527.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2529;
_1265920_2529.e0 = 1;
_1265920_2529.e1 = _1265919_2527;
pbh_upper_1279806 = _1265920_2529;
goto l1279804;
l1279804: ;
bh_upper_1279806 = pbh_upper_1279806;
int _1279807;
_1279807 = -1 + gid_y_1279777;
bool _1279808;
_1279808 = _1279807 < 0;
if (_1279808) goto l1279809; else goto l1279994;
l1279994: ;
union variant_220130 _1279995;
_1279995.qs32 = _1279807;
struct_BoundaryMode_220129 _1279996;
_1279996.e0 = 0;
_1279996.e1 = _1279995;
pbh_lower_1279812 = _1279996;
goto l1279810;
l1279809: ;
union variant_220130 _1265919_2538;
_1265919_2538.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2540;
_1265920_2540.e0 = 1;
_1265920_2540.e1 = _1265919_2538;
pbh_lower_1279812 = _1265920_2540;
goto l1279810;
l1279810: ;
bh_lower_1279812 = pbh_lower_1279812;
unsigned int _1279815;
_1279815 = bh_lower_1279812.e0;
union variant_220130 _1279819;
_1279819 = bh_lower_1279812.e1;
union variant_220130 _1279822;
_1279822 = bh_upper_1279806.e1;
unsigned int _1279813;
_1279813 = bh_upper_1279806.e0;
bool _1279816;
_1279816 = _1279815 == 0;
bool _1279814;
_1279814 = _1279813 == 0;
bool _1279817;
_1279817 = _1279814 & _1279816;
if (_1279817) goto l1279818; else goto l1279985;
l1279985: ;
bool _1279986;
_1279986 = _1279813 == 1;
if (_1279986) goto l1279987; else goto l1279989;
l1279989: ;
bool _1279990;
_1279990 = _1279815 == 1;
if (_1279990) goto l1279991; else goto l1279993;
l1279993: ;
// bottom: float r4_1265918_2552;
// bottom: p_1279831 = r4_1265918_2552;
goto l1279829;
l1279991: ;
float c_1279992;
c_1279992 = _1279819.pf32;
p_1279831 = c_1279992;
goto l1279829;
l1279987: ;
float c_1279988;
c_1279988 = _1279822.pf32;
p_1279831 = c_1279988;
goto l1279829;
l1279818: ;
int y_1279820;
y_1279820 = _1279819.qs32;
int _1279821;
_1279821 = y_1279820 * _1279791;
int x_1279823;
x_1279823 = _1279822.qs32;
int _1279824;
_1279824 = _1279821 + x_1279823;
float* idx_1279825;
idx_1279825 = _1045129_1279738 + _1279824;
_1279828 = __ldg(idx_1279825);
p_1279828 = _1279828;
l1279826: ;
_1279828 = p_1279828;
p_1279831 = _1279828;
goto l1279829;
l1279829: ;
_1279831 = p_1279831;
int _1279832;
_1279832 = -1 + gid_x_1279770;
bool _1279833;
_1279833 = _1279765 <= _1279832;
if (_1279833) goto l1279834; else goto l1279982;
l1279982: ;
union variant_220130 _1279983;
_1279983.qs32 = _1279832;
struct_BoundaryMode_220129 _1279984;
_1279984.e0 = 0;
_1279984.e1 = _1279983;
pbh_upper_1279837 = _1279984;
goto l1279835;
l1279834: ;
union variant_220130 _1265919_2557;
_1265919_2557.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2559;
_1265920_2559.e0 = 1;
_1265920_2559.e1 = _1265919_2557;
pbh_upper_1279837 = _1265920_2559;
goto l1279835;
l1279835: ;
bh_upper_1279837 = pbh_upper_1279837;
if (_1279778) goto l1279838; else goto l1279981;
l1279981: ;
pbh_lower_1279841 = _1279968;
goto l1279839;
l1279838: ;
union variant_220130 _1265919_2563;
_1265919_2563.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2565;
_1265920_2565.e0 = 1;
_1265920_2565.e1 = _1265919_2563;
pbh_lower_1279841 = _1265920_2565;
goto l1279839;
l1279839: ;
bh_lower_1279841 = pbh_lower_1279841;
union variant_220130 _1279851;
_1279851 = bh_upper_1279837.e1;
unsigned int _1279844;
_1279844 = bh_lower_1279841.e0;
union variant_220130 _1279848;
_1279848 = bh_lower_1279841.e1;
unsigned int _1279842;
_1279842 = bh_upper_1279837.e0;
bool _1279845;
_1279845 = _1279844 == 0;
bool _1279843;
_1279843 = _1279842 == 0;
bool _1279846;
_1279846 = _1279843 & _1279845;
if (_1279846) goto l1279847; else goto l1279972;
l1279972: ;
bool _1279973;
_1279973 = _1279842 == 1;
if (_1279973) goto l1279974; else goto l1279976;
l1279976: ;
bool _1279977;
_1279977 = _1279844 == 1;
if (_1279977) goto l1279978; else goto l1279980;
l1279980: ;
// bottom: float r4_1265918_2577;
// bottom: p_1279860 = r4_1265918_2577;
goto l1279858;
l1279978: ;
float c_1279979;
c_1279979 = _1279848.pf32;
p_1279860 = c_1279979;
goto l1279858;
l1279974: ;
float c_1279975;
c_1279975 = _1279851.pf32;
p_1279860 = c_1279975;
goto l1279858;
l1279847: ;
int y_1279849;
y_1279849 = _1279848.qs32;
int _1279850;
_1279850 = y_1279849 * _1279791;
int x_1279852;
x_1279852 = _1279851.qs32;
int _1279853;
_1279853 = _1279850 + x_1279852;
float* idx_1279854;
idx_1279854 = _1045129_1279738 + _1279853;
_1279857 = __ldg(idx_1279854);
p_1279857 = _1279857;
l1279855: ;
_1279857 = p_1279857;
p_1279860 = _1279857;
goto l1279858;
l1279858: ;
_1279860 = p_1279860;
int _1279861;
_1279861 = 1 + gid_x_1279770;
bool _1279862;
_1279862 = _1279765 <= _1279861;
if (_1279862) goto l1279863; else goto l1279969;
l1279969: ;
union variant_220130 _1279970;
_1279970.qs32 = _1279861;
struct_BoundaryMode_220129 _1279971;
_1279971.e0 = 0;
_1279971.e1 = _1279970;
pbh_upper_1279866 = _1279971;
goto l1279864;
l1279863: ;
union variant_220130 _1265919_2582;
_1265919_2582.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2584;
_1265920_2584.e0 = 1;
_1265920_2584.e1 = _1265919_2582;
pbh_upper_1279866 = _1265920_2584;
goto l1279864;
l1279864: ;
bh_upper_1279866 = pbh_upper_1279866;
if (_1279778) goto l1279867; else goto l1279966;
l1279966: ;
pbh_lower_1279870 = _1279968;
goto l1279868;
l1279867: ;
union variant_220130 _1265919_2588;
_1265919_2588.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2590;
_1265920_2590.e0 = 1;
_1265920_2590.e1 = _1265919_2588;
pbh_lower_1279870 = _1265920_2590;
goto l1279868;
l1279868: ;
bh_lower_1279870 = pbh_lower_1279870;
unsigned int _1279871;
_1279871 = bh_upper_1279866.e0;
union variant_220130 _1279877;
_1279877 = bh_lower_1279870.e1;
union variant_220130 _1279880;
_1279880 = bh_upper_1279866.e1;
bool _1279872;
_1279872 = _1279871 == 0;
unsigned int _1279873;
_1279873 = bh_lower_1279870.e0;
bool _1279874;
_1279874 = _1279873 == 0;
bool _1279875;
_1279875 = _1279872 & _1279874;
if (_1279875) goto l1279876; else goto l1279957;
l1279957: ;
bool _1279958;
_1279958 = _1279871 == 1;
if (_1279958) goto l1279959; else goto l1279961;
l1279961: ;
bool _1279962;
_1279962 = _1279873 == 1;
if (_1279962) goto l1279963; else goto l1279965;
l1279965: ;
// bottom: float r4_1265918_2602;
// bottom: p_1279889 = r4_1265918_2602;
goto l1279887;
l1279963: ;
float c_1279964;
c_1279964 = _1279877.pf32;
p_1279889 = c_1279964;
goto l1279887;
l1279959: ;
float c_1279960;
c_1279960 = _1279880.pf32;
p_1279889 = c_1279960;
goto l1279887;
l1279876: ;
int y_1279878;
y_1279878 = _1279877.qs32;
int x_1279881;
x_1279881 = _1279880.qs32;
int _1279879;
_1279879 = y_1279878 * _1279791;
int _1279882;
_1279882 = _1279879 + x_1279881;
float* idx_1279883;
idx_1279883 = _1045129_1279738 + _1279882;
_1279886 = __ldg(idx_1279883);
p_1279886 = _1279886;
l1279884: ;
_1279886 = p_1279886;
p_1279889 = _1279886;
goto l1279887;
l1279887: ;
_1279889 = p_1279889;
if (_1279771) goto l1279890; else goto l1279954;
l1279954: ;
pbh_upper_1279893 = _1279956;
goto l1279891;
l1279890: ;
union variant_220130 _1265919_2603;
_1265919_2603.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2605;
_1265920_2605.e0 = 1;
_1265920_2605.e1 = _1265919_2603;
pbh_upper_1279893 = _1265920_2605;
goto l1279891;
l1279891: ;
bh_upper_1279893 = pbh_upper_1279893;
int _1279894;
_1279894 = 1 + gid_y_1279777;
bool _1279895;
_1279895 = _1279894 < 0;
if (_1279895) goto l1279896; else goto l1279951;
l1279951: ;
union variant_220130 _1279952;
_1279952.qs32 = _1279894;
struct_BoundaryMode_220129 _1279953;
_1279953.e0 = 0;
_1279953.e1 = _1279952;
pbh_lower_1279899 = _1279953;
goto l1279897;
l1279896: ;
union variant_220130 _1265919_2614;
_1265919_2614.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2616;
_1265920_2616.e0 = 1;
_1265920_2616.e1 = _1265919_2614;
pbh_lower_1279899 = _1265920_2616;
goto l1279897;
l1279897: ;
bh_lower_1279899 = pbh_lower_1279899;
unsigned int _1279902;
_1279902 = bh_lower_1279899.e0;
union variant_220130 _1279909;
_1279909 = bh_upper_1279893.e1;
unsigned int _1279900;
_1279900 = bh_upper_1279893.e0;
union variant_220130 _1279906;
_1279906 = bh_lower_1279899.e1;
bool _1279903;
_1279903 = _1279902 == 0;
bool _1279901;
_1279901 = _1279900 == 0;
bool _1279904;
_1279904 = _1279901 & _1279903;
if (_1279904) goto l1279905; else goto l1279942;
l1279942: ;
bool _1279943;
_1279943 = _1279900 == 1;
if (_1279943) goto l1279944; else goto l1279946;
l1279946: ;
bool _1279947;
_1279947 = _1279902 == 1;
if (_1279947) goto l1279948; else goto l1279950;
l1279950: ;
// bottom: float r4_1265918_2628;
// bottom: p_1279918 = r4_1265918_2628;
goto l1279916;
l1279948: ;
float c_1279949;
c_1279949 = _1279906.pf32;
p_1279918 = c_1279949;
goto l1279916;
l1279944: ;
float c_1279945;
c_1279945 = _1279909.pf32;
p_1279918 = c_1279945;
goto l1279916;
l1279905: ;
int x_1279910;
x_1279910 = _1279909.qs32;
int y_1279907;
y_1279907 = _1279906.qs32;
int _1279908;
_1279908 = y_1279907 * _1279791;
int _1279911;
_1279911 = _1279908 + x_1279910;
float* idx_1279912;
idx_1279912 = _1045129_1279738 + _1279911;
_1279915 = __ldg(idx_1279912);
p_1279915 = _1279915;
l1279913: ;
_1279915 = p_1279915;
p_1279918 = _1279915;
goto l1279916;
l1279916: ;
_1279918 = p_1279918;
float _1279929;
_1279929 = _1279928;
float _1279930;
_1279930 = 2.000000e-01f * _1279929;
float _1279938;
_1279938 = 2.500000e-01f * _1279918;
int _1279919;
_1279919 = _1045133_1279742.e3;
float _1279923;
_1279923 = 2.000000e-01f * _1279802;
float _1279932;
_1279932 = 2.500000e-01f * _1279831;
int _1279920;
_1279920 = gid_y_1279777 * _1279919;
float _1279934;
_1279934 = 2.500000e-01f * _1279860;
float _1279936;
_1279936 = 2.500000e-01f * _1279889;
float _1279933;
_1279933 = 0.000000e+00f + _1279932;
float _1279931;
_1279931 = _1279923 + _1279930;
int _1279921;
_1279921 = _1279920 + gid_x_1279770;
float _1279935;
_1279935 = _1279933 + _1279934;
float _1279937;
_1279937 = _1279935 + _1279936;
float* idx_1279922;
idx_1279922 = _1045132_1279741 + _1279921;
float _1279939;
_1279939 = _1279937 + _1279938;
float val_1279940;
val_1279940 = _1279931 + _1279939;
*idx_1279922 = val_1279940;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1016900(struct_Img_220118 _1016903_1285391, float* _1016904_1285392, struct_Img_220118 _1016905_1285393, float* _1016906_1285394, struct_Img_220118 _1016907_1285395, float* _1016908_1285396) {
int _1285399;
int p_1285399;
int _1285402;
int p_1285402;
int _1285405;
int p_1285405;
int _1285408;
int p_1285408;
int _1285411;
int p_1285411;
int _1285414;
int p_1285414;
int _1285417;
int p_1285417;
struct_BoundaryMode_220129 bh_upper_1285428;
struct_BoundaryMode_220129 pbh_upper_1285428;
struct_BoundaryMode_220129 bh_lower_1285435;
struct_BoundaryMode_220129 pbh_lower_1285435;
float _1285452;
float p_1285452;
float _1285455;
float p_1285455;
struct_BoundaryMode_220129 bh_upper_1285459;
struct_BoundaryMode_220129 pbh_upper_1285459;
struct_BoundaryMode_220129 bh_lower_1285465;
struct_BoundaryMode_220129 pbh_lower_1285465;
float _1285481;
float p_1285481;
float _1285484;
float p_1285484;
struct_BoundaryMode_220129 bh_upper_1285490;
struct_BoundaryMode_220129 pbh_upper_1285490;
struct_BoundaryMode_220129 bh_lower_1285494;
struct_BoundaryMode_220129 pbh_lower_1285494;
float _1285510;
float p_1285510;
float _1285513;
float p_1285513;
struct_BoundaryMode_220129 bh_upper_1285519;
struct_BoundaryMode_220129 pbh_upper_1285519;
struct_BoundaryMode_220129 bh_lower_1285523;
struct_BoundaryMode_220129 pbh_lower_1285523;
float _1285539;
float p_1285539;
float _1285542;
float p_1285542;
struct_BoundaryMode_220129 bh_upper_1285546;
struct_BoundaryMode_220129 pbh_upper_1285546;
struct_BoundaryMode_220129 bh_lower_1285552;
struct_BoundaryMode_220129 pbh_lower_1285552;
float _1285568;
float p_1285568;
float _1285571;
float p_1285571;
_1285399 = threadIdx_x();
p_1285399 = _1285399;
l1285397: ;
_1285399 = p_1285399;
_1285402 = blockDim_x();
p_1285402 = _1285402;
l1285400: ;
_1285402 = p_1285402;
_1285405 = blockIdx_x();
p_1285405 = _1285405;
l1285403: ;
_1285405 = p_1285405;
_1285408 = threadIdx_y();
p_1285408 = _1285408;
l1285406: ;
_1285408 = p_1285408;
_1285411 = blockDim_y();
p_1285411 = _1285411;
l1285409: ;
_1285411 = p_1285411;
_1285414 = blockIdx_y();
p_1285414 = _1285414;
l1285412: ;
_1285414 = p_1285414;
_1285417 = blockDim_y();
p_1285417 = _1285417;
l1285415: ;
_1285417 = p_1285417;
int _1285419;
_1285419 = _1016905_1285393.e1;
int _1285422;
_1285422 = _1285402 * _1285405;
int _1285420;
_1285420 = _1285419 - 128;
int _1285418;
_1285418 = _1016907_1285395.e1;
int _1285421;
_1285421 = _1285420 + _1285399;
int gid_x_1285423;
gid_x_1285423 = _1285421 + _1285422;
union variant_220130 _1285608;
_1285608.qs32 = gid_x_1285423;
bool _1285424;
_1285424 = _1285418 <= gid_x_1285423;
struct_BoundaryMode_220129 _1285609;
_1285609.e0 = 0;
_1285609.e1 = _1285608;
if (_1285424) goto l1285425; else goto l1285662;
l1285662: ;
pbh_upper_1285428 = _1285609;
goto l1285426;
l1285425: ;
union variant_220130 _1265919_2643;
_1265919_2643.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2645;
_1265920_2645.e0 = 1;
_1265920_2645.e1 = _1265919_2643;
pbh_upper_1285428 = _1265920_2645;
goto l1285426;
l1285426: ;
bh_upper_1285428 = pbh_upper_1285428;
int _1285429;
_1285429 = _1285411 * _1285414;
int gid_y_1285430;
gid_y_1285430 = _1285408 + _1285429;
bool _1285431;
_1285431 = gid_y_1285430 < 0;
union variant_220130 _1285620;
_1285620.qs32 = gid_y_1285430;
struct_BoundaryMode_220129 _1285621;
_1285621.e0 = 0;
_1285621.e1 = _1285620;
if (_1285431) goto l1285432; else goto l1285661;
l1285661: ;
pbh_lower_1285435 = _1285621;
goto l1285433;
l1285432: ;
union variant_220130 _1265919_2653;
_1265919_2653.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2655;
_1265920_2655.e0 = 1;
_1265920_2655.e1 = _1265919_2653;
pbh_lower_1285435 = _1265920_2655;
goto l1285433;
l1285433: ;
bh_lower_1285435 = pbh_lower_1285435;
unsigned int _1285436;
_1285436 = bh_upper_1285428.e0;
unsigned int _1285438;
_1285438 = bh_lower_1285435.e0;
union variant_220130 _1285446;
_1285446 = bh_upper_1285428.e1;
bool _1285437;
_1285437 = _1285436 == 0;
int _1285444;
_1285444 = _1016907_1285395.e3;
union variant_220130 _1285442;
_1285442 = bh_lower_1285435.e1;
bool _1285439;
_1285439 = _1285438 == 0;
bool _1285440;
_1285440 = _1285437 & _1285439;
if (_1285440) goto l1285441; else goto l1285652;
l1285652: ;
bool _1285653;
_1285653 = _1285436 == 1;
if (_1285653) goto l1285654; else goto l1285656;
l1285656: ;
bool _1285657;
_1285657 = _1285438 == 1;
if (_1285657) goto l1285658; else goto l1285660;
l1285660: ;
// bottom: float r4_1265918_2668;
// bottom: p_1285455 = r4_1265918_2668;
goto l1285453;
l1285658: ;
float c_1285659;
c_1285659 = _1285442.pf32;
p_1285455 = c_1285659;
goto l1285453;
l1285654: ;
float c_1285655;
c_1285655 = _1285446.pf32;
p_1285455 = c_1285655;
goto l1285453;
l1285441: ;
int x_1285447;
x_1285447 = _1285446.qs32;
int y_1285443;
y_1285443 = _1285442.qs32;
int _1285445;
_1285445 = y_1285443 * _1285444;
int _1285448;
_1285448 = _1285445 + x_1285447;
float* idx_1285449;
idx_1285449 = _1016906_1285394 + _1285448;
_1285452 = __ldg(idx_1285449);
p_1285452 = _1285452;
l1285450: ;
_1285452 = p_1285452;
p_1285455 = _1285452;
goto l1285453;
l1285453: ;
_1285455 = p_1285455;
int _1285577;
_1285577 = _1016903_1285391.e3;
int _1285578;
_1285578 = gid_y_1285430 * _1285577;
int _1285579;
_1285579 = _1285578 + gid_x_1285423;
float* idx_1285580;
idx_1285580 = _1016908_1285396 + _1285579;
float _1285581;
_1285581 = *idx_1285580;
if (_1285424) goto l1285456; else goto l1285651;
l1285651: ;
pbh_upper_1285459 = _1285609;
goto l1285457;
l1285456: ;
union variant_220130 _1265919_2670;
_1265919_2670.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2672;
_1265920_2672.e0 = 1;
_1265920_2672.e1 = _1265919_2670;
pbh_upper_1285459 = _1265920_2672;
goto l1285457;
l1285457: ;
bh_upper_1285459 = pbh_upper_1285459;
int _1285460;
_1285460 = -1 + gid_y_1285430;
bool _1285461;
_1285461 = _1285460 < 0;
if (_1285461) goto l1285462; else goto l1285647;
l1285647: ;
union variant_220130 _1285648;
_1285648.qs32 = _1285460;
struct_BoundaryMode_220129 _1285649;
_1285649.e0 = 0;
_1285649.e1 = _1285648;
pbh_lower_1285465 = _1285649;
goto l1285463;
l1285462: ;
union variant_220130 _1265919_2681;
_1265919_2681.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2683;
_1265920_2683.e0 = 1;
_1265920_2683.e1 = _1265919_2681;
pbh_lower_1285465 = _1265920_2683;
goto l1285463;
l1285463: ;
bh_lower_1285465 = pbh_lower_1285465;
unsigned int _1285468;
_1285468 = bh_lower_1285465.e0;
union variant_220130 _1285472;
_1285472 = bh_lower_1285465.e1;
bool _1285469;
_1285469 = _1285468 == 0;
union variant_220130 _1285475;
_1285475 = bh_upper_1285459.e1;
unsigned int _1285466;
_1285466 = bh_upper_1285459.e0;
bool _1285467;
_1285467 = _1285466 == 0;
bool _1285470;
_1285470 = _1285467 & _1285469;
if (_1285470) goto l1285471; else goto l1285638;
l1285638: ;
bool _1285639;
_1285639 = _1285466 == 1;
if (_1285639) goto l1285640; else goto l1285642;
l1285642: ;
bool _1285643;
_1285643 = _1285468 == 1;
if (_1285643) goto l1285644; else goto l1285646;
l1285646: ;
// bottom: float r4_1265918_2695;
// bottom: p_1285484 = r4_1265918_2695;
goto l1285482;
l1285644: ;
float c_1285645;
c_1285645 = _1285472.pf32;
p_1285484 = c_1285645;
goto l1285482;
l1285640: ;
float c_1285641;
c_1285641 = _1285475.pf32;
p_1285484 = c_1285641;
goto l1285482;
l1285471: ;
int y_1285473;
y_1285473 = _1285472.qs32;
int x_1285476;
x_1285476 = _1285475.qs32;
int _1285474;
_1285474 = y_1285473 * _1285444;
int _1285477;
_1285477 = _1285474 + x_1285476;
float* idx_1285478;
idx_1285478 = _1016906_1285394 + _1285477;
_1285481 = __ldg(idx_1285478);
p_1285481 = _1285481;
l1285479: ;
_1285481 = p_1285481;
p_1285484 = _1285481;
goto l1285482;
l1285482: ;
_1285484 = p_1285484;
int _1285485;
_1285485 = -1 + gid_x_1285423;
bool _1285486;
_1285486 = _1285418 <= _1285485;
if (_1285486) goto l1285487; else goto l1285635;
l1285635: ;
union variant_220130 _1285636;
_1285636.qs32 = _1285485;
struct_BoundaryMode_220129 _1285637;
_1285637.e0 = 0;
_1285637.e1 = _1285636;
pbh_upper_1285490 = _1285637;
goto l1285488;
l1285487: ;
union variant_220130 _1265919_2700;
_1265919_2700.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2702;
_1265920_2702.e0 = 1;
_1265920_2702.e1 = _1265919_2700;
pbh_upper_1285490 = _1265920_2702;
goto l1285488;
l1285488: ;
bh_upper_1285490 = pbh_upper_1285490;
if (_1285431) goto l1285491; else goto l1285634;
l1285634: ;
pbh_lower_1285494 = _1285621;
goto l1285492;
l1285491: ;
union variant_220130 _1265919_2706;
_1265919_2706.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2708;
_1265920_2708.e0 = 1;
_1265920_2708.e1 = _1265919_2706;
pbh_lower_1285494 = _1265920_2708;
goto l1285492;
l1285492: ;
bh_lower_1285494 = pbh_lower_1285494;
union variant_220130 _1285504;
_1285504 = bh_upper_1285490.e1;
union variant_220130 _1285501;
_1285501 = bh_lower_1285494.e1;
unsigned int _1285495;
_1285495 = bh_upper_1285490.e0;
unsigned int _1285497;
_1285497 = bh_lower_1285494.e0;
bool _1285498;
_1285498 = _1285497 == 0;
bool _1285496;
_1285496 = _1285495 == 0;
bool _1285499;
_1285499 = _1285496 & _1285498;
if (_1285499) goto l1285500; else goto l1285625;
l1285625: ;
bool _1285626;
_1285626 = _1285495 == 1;
if (_1285626) goto l1285627; else goto l1285629;
l1285629: ;
bool _1285630;
_1285630 = _1285497 == 1;
if (_1285630) goto l1285631; else goto l1285633;
l1285633: ;
// bottom: float r4_1265918_2720;
// bottom: p_1285513 = r4_1265918_2720;
goto l1285511;
l1285631: ;
float c_1285632;
c_1285632 = _1285501.pf32;
p_1285513 = c_1285632;
goto l1285511;
l1285627: ;
float c_1285628;
c_1285628 = _1285504.pf32;
p_1285513 = c_1285628;
goto l1285511;
l1285500: ;
int x_1285505;
x_1285505 = _1285504.qs32;
int y_1285502;
y_1285502 = _1285501.qs32;
int _1285503;
_1285503 = y_1285502 * _1285444;
int _1285506;
_1285506 = _1285503 + x_1285505;
float* idx_1285507;
idx_1285507 = _1016906_1285394 + _1285506;
_1285510 = __ldg(idx_1285507);
p_1285510 = _1285510;
l1285508: ;
_1285510 = p_1285510;
p_1285513 = _1285510;
goto l1285511;
l1285511: ;
_1285513 = p_1285513;
int _1285514;
_1285514 = 1 + gid_x_1285423;
bool _1285515;
_1285515 = _1285418 <= _1285514;
if (_1285515) goto l1285516; else goto l1285622;
l1285622: ;
union variant_220130 _1285623;
_1285623.qs32 = _1285514;
struct_BoundaryMode_220129 _1285624;
_1285624.e0 = 0;
_1285624.e1 = _1285623;
pbh_upper_1285519 = _1285624;
goto l1285517;
l1285516: ;
union variant_220130 _1265919_2725;
_1265919_2725.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2727;
_1265920_2727.e0 = 1;
_1265920_2727.e1 = _1265919_2725;
pbh_upper_1285519 = _1265920_2727;
goto l1285517;
l1285517: ;
bh_upper_1285519 = pbh_upper_1285519;
if (_1285431) goto l1285520; else goto l1285619;
l1285619: ;
pbh_lower_1285523 = _1285621;
goto l1285521;
l1285520: ;
union variant_220130 _1265919_2731;
_1265919_2731.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2733;
_1265920_2733.e0 = 1;
_1265920_2733.e1 = _1265919_2731;
pbh_lower_1285523 = _1265920_2733;
goto l1285521;
l1285521: ;
bh_lower_1285523 = pbh_lower_1285523;
union variant_220130 _1285533;
_1285533 = bh_upper_1285519.e1;
unsigned int _1285526;
_1285526 = bh_lower_1285523.e0;
union variant_220130 _1285530;
_1285530 = bh_lower_1285523.e1;
unsigned int _1285524;
_1285524 = bh_upper_1285519.e0;
bool _1285525;
_1285525 = _1285524 == 0;
bool _1285527;
_1285527 = _1285526 == 0;
bool _1285528;
_1285528 = _1285525 & _1285527;
if (_1285528) goto l1285529; else goto l1285610;
l1285610: ;
bool _1285611;
_1285611 = _1285524 == 1;
if (_1285611) goto l1285612; else goto l1285614;
l1285614: ;
bool _1285615;
_1285615 = _1285526 == 1;
if (_1285615) goto l1285616; else goto l1285618;
l1285618: ;
// bottom: float r4_1265918_2745;
// bottom: p_1285542 = r4_1265918_2745;
goto l1285540;
l1285616: ;
float c_1285617;
c_1285617 = _1285530.pf32;
p_1285542 = c_1285617;
goto l1285540;
l1285612: ;
float c_1285613;
c_1285613 = _1285533.pf32;
p_1285542 = c_1285613;
goto l1285540;
l1285529: ;
int x_1285534;
x_1285534 = _1285533.qs32;
int y_1285531;
y_1285531 = _1285530.qs32;
int _1285532;
_1285532 = y_1285531 * _1285444;
int _1285535;
_1285535 = _1285532 + x_1285534;
float* idx_1285536;
idx_1285536 = _1016906_1285394 + _1285535;
_1285539 = __ldg(idx_1285536);
p_1285539 = _1285539;
l1285537: ;
_1285539 = p_1285539;
p_1285542 = _1285539;
goto l1285540;
l1285540: ;
_1285542 = p_1285542;
if (_1285424) goto l1285543; else goto l1285607;
l1285607: ;
pbh_upper_1285546 = _1285609;
goto l1285544;
l1285543: ;
union variant_220130 _1265919_2746;
_1265919_2746.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2748;
_1265920_2748.e0 = 1;
_1265920_2748.e1 = _1265919_2746;
pbh_upper_1285546 = _1265920_2748;
goto l1285544;
l1285544: ;
bh_upper_1285546 = pbh_upper_1285546;
int _1285547;
_1285547 = 1 + gid_y_1285430;
bool _1285548;
_1285548 = _1285547 < 0;
if (_1285548) goto l1285549; else goto l1285604;
l1285604: ;
union variant_220130 _1285605;
_1285605.qs32 = _1285547;
struct_BoundaryMode_220129 _1285606;
_1285606.e0 = 0;
_1285606.e1 = _1285605;
pbh_lower_1285552 = _1285606;
goto l1285550;
l1285549: ;
union variant_220130 _1265919_2757;
_1265919_2757.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2759;
_1265920_2759.e0 = 1;
_1265920_2759.e1 = _1265919_2757;
pbh_lower_1285552 = _1265920_2759;
goto l1285550;
l1285550: ;
bh_lower_1285552 = pbh_lower_1285552;
unsigned int _1285553;
_1285553 = bh_upper_1285546.e0;
union variant_220130 _1285559;
_1285559 = bh_lower_1285552.e1;
bool _1285554;
_1285554 = _1285553 == 0;
unsigned int _1285555;
_1285555 = bh_lower_1285552.e0;
bool _1285556;
_1285556 = _1285555 == 0;
union variant_220130 _1285562;
_1285562 = bh_upper_1285546.e1;
bool _1285557;
_1285557 = _1285554 & _1285556;
if (_1285557) goto l1285558; else goto l1285595;
l1285595: ;
bool _1285596;
_1285596 = _1285553 == 1;
if (_1285596) goto l1285597; else goto l1285599;
l1285599: ;
bool _1285600;
_1285600 = _1285555 == 1;
if (_1285600) goto l1285601; else goto l1285603;
l1285603: ;
// bottom: float r4_1265918_2771;
// bottom: p_1285571 = r4_1265918_2771;
goto l1285569;
l1285601: ;
float c_1285602;
c_1285602 = _1285559.pf32;
p_1285571 = c_1285602;
goto l1285569;
l1285597: ;
float c_1285598;
c_1285598 = _1285562.pf32;
p_1285571 = c_1285598;
goto l1285569;
l1285558: ;
int x_1285563;
x_1285563 = _1285562.qs32;
int y_1285560;
y_1285560 = _1285559.qs32;
int _1285561;
_1285561 = y_1285560 * _1285444;
int _1285564;
_1285564 = _1285561 + x_1285563;
float* idx_1285565;
idx_1285565 = _1016906_1285394 + _1285564;
_1285568 = __ldg(idx_1285565);
p_1285568 = _1285568;
l1285566: ;
_1285568 = p_1285568;
p_1285571 = _1285568;
goto l1285569;
l1285569: ;
_1285571 = p_1285571;
float _1285591;
_1285591 = 2.500000e-01f * _1285571;
float _1285589;
_1285589 = 2.500000e-01f * _1285542;
float _1285582;
_1285582 = _1285581;
float _1285576;
_1285576 = 2.000000e-01f * _1285455;
int _1285572;
_1285572 = _1016905_1285393.e3;
float _1285585;
_1285585 = 2.500000e-01f * _1285484;
float _1285586;
_1285586 = 0.000000e+00f + _1285585;
float _1285587;
_1285587 = 2.500000e-01f * _1285513;
float _1285583;
_1285583 = 2.000000e-01f * _1285582;
float _1285584;
_1285584 = _1285576 + _1285583;
int _1285573;
_1285573 = gid_y_1285430 * _1285572;
float _1285588;
_1285588 = _1285586 + _1285587;
int _1285574;
_1285574 = _1285573 + gid_x_1285423;
float _1285590;
_1285590 = _1285588 + _1285589;
float* idx_1285575;
idx_1285575 = _1016904_1285392 + _1285574;
float _1285592;
_1285592 = _1285590 + _1285591;
float val_1285593;
val_1285593 = _1285584 + _1285592;
*idx_1285575 = val_1285593;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1001392(struct_Img_220118 _1001395_1271272, float* _1001396_1271273, struct_Img_220118 _1001397_1271274, float* _1001398_1271275, float* _1001399_1271276, struct_Img_220118 _1001400_1271277) {
int _1271280;
int p_1271280;
int _1271283;
int p_1271283;
int _1271286;
int p_1271286;
int _1271289;
int p_1271289;
int _1271292;
int p_1271292;
int _1271295;
int p_1271295;
int _1271298;
int p_1271298;
struct_BoundaryMode_220129 bh_lower_1271305;
struct_BoundaryMode_220129 pbh_lower_1271305;
float _1271320;
float p_1271320;
float _1271323;
float p_1271323;
struct_BoundaryMode_220129 bh_lower_1271329;
struct_BoundaryMode_220129 pbh_lower_1271329;
float _1271341;
float p_1271341;
float _1271344;
float p_1271344;
struct_BoundaryMode_220129 bh_lower_1271348;
struct_BoundaryMode_220129 pbh_lower_1271348;
float _1271360;
float p_1271360;
float _1271363;
float p_1271363;
struct_BoundaryMode_220129 bh_lower_1271367;
struct_BoundaryMode_220129 pbh_lower_1271367;
float _1271379;
float p_1271379;
float _1271382;
float p_1271382;
struct_BoundaryMode_220129 bh_lower_1271388;
struct_BoundaryMode_220129 pbh_lower_1271388;
float _1271400;
float p_1271400;
float _1271403;
float p_1271403;
_1271280 = threadIdx_x();
p_1271280 = _1271280;
l1271278: ;
_1271280 = p_1271280;
_1271283 = blockDim_x();
p_1271283 = _1271283;
l1271281: ;
_1271283 = p_1271283;
_1271286 = blockIdx_x();
p_1271286 = _1271286;
l1271284: ;
_1271286 = p_1271286;
_1271289 = threadIdx_y();
p_1271289 = _1271289;
l1271287: ;
_1271289 = p_1271289;
_1271292 = blockDim_y();
p_1271292 = _1271292;
l1271290: ;
_1271292 = p_1271292;
_1271295 = blockIdx_y();
p_1271295 = _1271295;
l1271293: ;
_1271295 = p_1271295;
_1271298 = blockDim_y();
p_1271298 = _1271298;
l1271296: ;
_1271298 = p_1271298;
int _1271299;
_1271299 = _1271292 * _1271295;
int gid_y_1271300;
gid_y_1271300 = _1271289 + _1271299;
bool _1271301;
_1271301 = gid_y_1271300 < 0;
union variant_220130 _1271443;
_1271443.qs32 = gid_y_1271300;
struct_BoundaryMode_220129 _1271444;
_1271444.e0 = 0;
_1271444.e1 = _1271443;
if (_1271301) goto l1271302; else goto l1271465;
l1271465: ;
pbh_lower_1271305 = _1271444;
goto l1271303;
l1271302: ;
union variant_220130 _1265919_2784;
_1265919_2784.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2786;
_1265920_2786.e0 = 1;
_1265920_2786.e1 = _1265919_2784;
pbh_lower_1271305 = _1265920_2786;
goto l1271303;
l1271303: ;
bh_lower_1271305 = pbh_lower_1271305;
int _1271311;
_1271311 = _1001395_1271272.e3;
unsigned int _1271306;
_1271306 = bh_lower_1271305.e0;
int _1271313;
_1271313 = _1271283 * _1271286;
bool _1271307;
_1271307 = _1271306 == 0;
union variant_220130 _1271309;
_1271309 = bh_lower_1271305.e1;
int gid_x_1271314;
gid_x_1271314 = _1271280 + _1271313;
if (_1271307) goto l1271308; else goto l1271460;
l1271460: ;
bool _1271461;
_1271461 = _1271306 == 1;
if (_1271461) goto l1271462; else goto l1271464;
l1271464: ;
// bottom: float r4_1265918_2795;
// bottom: p_1271323 = r4_1265918_2795;
goto l1271321;
l1271462: ;
float c_1271463;
c_1271463 = _1271309.pf32;
p_1271323 = c_1271463;
goto l1271321;
l1271308: ;
int y_1271310;
y_1271310 = _1271309.qs32;
int _1271312;
_1271312 = y_1271310 * _1271311;
int _1271315;
_1271315 = _1271312 + gid_x_1271314;
int _1271316;
_1271316 = 128 + _1271315;
float* idx_1271317;
idx_1271317 = _1001396_1271273 + _1271316;
_1271320 = __ldg(idx_1271317);
p_1271320 = _1271320;
l1271318: ;
_1271320 = p_1271320;
p_1271323 = _1271320;
goto l1271321;
l1271321: ;
_1271323 = p_1271323;
int _1271324;
_1271324 = -1 + gid_y_1271300;
int _1271410;
_1271410 = _1001397_1271274.e3;
bool _1271325;
_1271325 = _1271324 < 0;
int _1271411;
_1271411 = gid_y_1271300 * _1271410;
int _1271412;
_1271412 = _1271411 + gid_x_1271314;
int _1271413;
_1271413 = 128 + _1271412;
float* idx_1271414;
idx_1271414 = _1001399_1271276 + _1271413;
float _1271415;
_1271415 = *idx_1271414;
if (_1271325) goto l1271326; else goto l1271457;
l1271457: ;
union variant_220130 _1271458;
_1271458.qs32 = _1271324;
struct_BoundaryMode_220129 _1271459;
_1271459.e0 = 0;
_1271459.e1 = _1271458;
pbh_lower_1271329 = _1271459;
goto l1271327;
l1271326: ;
union variant_220130 _1265919_2804;
_1265919_2804.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2806;
_1265920_2806.e0 = 1;
_1265920_2806.e1 = _1265919_2804;
pbh_lower_1271329 = _1265920_2806;
goto l1271327;
l1271327: ;
bh_lower_1271329 = pbh_lower_1271329;
union variant_220130 _1271333;
_1271333 = bh_lower_1271329.e1;
unsigned int _1271330;
_1271330 = bh_lower_1271329.e0;
bool _1271331;
_1271331 = _1271330 == 0;
if (_1271331) goto l1271332; else goto l1271451;
l1271451: ;
bool _1271452;
_1271452 = _1271330 == 1;
if (_1271452) goto l1271453; else goto l1271455;
l1271455: ;
// bottom: float r4_1265918_2814;
// bottom: p_1271344 = r4_1265918_2814;
goto l1271342;
l1271453: ;
float c_1271454;
c_1271454 = _1271333.pf32;
p_1271344 = c_1271454;
goto l1271342;
l1271332: ;
int y_1271334;
y_1271334 = _1271333.qs32;
int _1271335;
_1271335 = y_1271334 * _1271311;
int _1271336;
_1271336 = _1271335 + gid_x_1271314;
int _1271337;
_1271337 = 128 + _1271336;
float* idx_1271338;
idx_1271338 = _1001396_1271273 + _1271337;
_1271341 = __ldg(idx_1271338);
p_1271341 = _1271341;
l1271339: ;
_1271341 = p_1271341;
p_1271344 = _1271341;
goto l1271342;
l1271342: ;
_1271344 = p_1271344;
if (_1271301) goto l1271345; else goto l1271450;
l1271450: ;
pbh_lower_1271348 = _1271444;
goto l1271346;
l1271345: ;
union variant_220130 _1265919_2816;
_1265919_2816.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2818;
_1265920_2818.e0 = 1;
_1265920_2818.e1 = _1265919_2816;
pbh_lower_1271348 = _1265920_2818;
goto l1271346;
l1271346: ;
bh_lower_1271348 = pbh_lower_1271348;
union variant_220130 _1271352;
_1271352 = bh_lower_1271348.e1;
unsigned int _1271349;
_1271349 = bh_lower_1271348.e0;
bool _1271350;
_1271350 = _1271349 == 0;
if (_1271350) goto l1271351; else goto l1271445;
l1271445: ;
bool _1271446;
_1271446 = _1271349 == 1;
if (_1271446) goto l1271447; else goto l1271449;
l1271449: ;
// bottom: float r4_1265918_2826;
// bottom: p_1271363 = r4_1265918_2826;
goto l1271361;
l1271447: ;
float c_1271448;
c_1271448 = _1271352.pf32;
p_1271363 = c_1271448;
goto l1271361;
l1271351: ;
int y_1271353;
y_1271353 = _1271352.qs32;
int _1271354;
_1271354 = y_1271353 * _1271311;
int _1271355;
_1271355 = _1271354 + gid_x_1271314;
int _1271356;
_1271356 = 127 + _1271355;
float* idx_1271357;
idx_1271357 = _1001396_1271273 + _1271356;
_1271360 = __ldg(idx_1271357);
p_1271360 = _1271360;
l1271358: ;
_1271360 = p_1271360;
p_1271363 = _1271360;
goto l1271361;
l1271361: ;
_1271363 = p_1271363;
if (_1271301) goto l1271364; else goto l1271442;
l1271442: ;
pbh_lower_1271367 = _1271444;
goto l1271365;
l1271364: ;
union variant_220130 _1265919_2828;
_1265919_2828.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2830;
_1265920_2830.e0 = 1;
_1265920_2830.e1 = _1265919_2828;
pbh_lower_1271367 = _1265920_2830;
goto l1271365;
l1271365: ;
bh_lower_1271367 = pbh_lower_1271367;
union variant_220130 _1271371;
_1271371 = bh_lower_1271367.e1;
unsigned int _1271368;
_1271368 = bh_lower_1271367.e0;
bool _1271369;
_1271369 = _1271368 == 0;
if (_1271369) goto l1271370; else goto l1271437;
l1271437: ;
bool _1271438;
_1271438 = _1271368 == 1;
if (_1271438) goto l1271439; else goto l1271441;
l1271441: ;
// bottom: float r4_1265918_2838;
// bottom: p_1271382 = r4_1265918_2838;
goto l1271380;
l1271439: ;
float c_1271440;
c_1271440 = _1271371.pf32;
p_1271382 = c_1271440;
goto l1271380;
l1271370: ;
int y_1271372;
y_1271372 = _1271371.qs32;
int _1271373;
_1271373 = y_1271372 * _1271311;
int _1271374;
_1271374 = _1271373 + gid_x_1271314;
int _1271375;
_1271375 = 129 + _1271374;
float* idx_1271376;
idx_1271376 = _1001396_1271273 + _1271375;
_1271379 = __ldg(idx_1271376);
p_1271379 = _1271379;
l1271377: ;
_1271379 = p_1271379;
p_1271382 = _1271379;
goto l1271380;
l1271380: ;
_1271382 = p_1271382;
int _1271383;
_1271383 = 1 + gid_y_1271300;
bool _1271384;
_1271384 = _1271383 < 0;
if (_1271384) goto l1271385; else goto l1271434;
l1271434: ;
union variant_220130 _1271435;
_1271435.qs32 = _1271383;
struct_BoundaryMode_220129 _1271436;
_1271436.e0 = 0;
_1271436.e1 = _1271435;
pbh_lower_1271388 = _1271436;
goto l1271386;
l1271385: ;
union variant_220130 _1265919_2845;
_1265919_2845.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2847;
_1265920_2847.e0 = 1;
_1265920_2847.e1 = _1265919_2845;
pbh_lower_1271388 = _1265920_2847;
goto l1271386;
l1271386: ;
bh_lower_1271388 = pbh_lower_1271388;
unsigned int _1271389;
_1271389 = bh_lower_1271388.e0;
union variant_220130 _1271392;
_1271392 = bh_lower_1271388.e1;
bool _1271390;
_1271390 = _1271389 == 0;
if (_1271390) goto l1271391; else goto l1271429;
l1271429: ;
bool _1271430;
_1271430 = _1271389 == 1;
if (_1271430) goto l1271431; else goto l1271433;
l1271433: ;
// bottom: float r4_1265918_2855;
// bottom: p_1271403 = r4_1265918_2855;
goto l1271401;
l1271431: ;
float c_1271432;
c_1271432 = _1271392.pf32;
p_1271403 = c_1271432;
goto l1271401;
l1271391: ;
int y_1271393;
y_1271393 = _1271392.qs32;
int _1271394;
_1271394 = y_1271393 * _1271311;
int _1271395;
_1271395 = _1271394 + gid_x_1271314;
int _1271396;
_1271396 = 128 + _1271395;
float* idx_1271397;
idx_1271397 = _1001396_1271273 + _1271396;
_1271400 = __ldg(idx_1271397);
p_1271400 = _1271400;
l1271398: ;
_1271400 = p_1271400;
p_1271403 = _1271400;
goto l1271401;
l1271401: ;
_1271403 = p_1271403;
float _1271419;
_1271419 = 2.500000e-01f * _1271344;
float _1271416;
_1271416 = _1271415;
float _1271417;
_1271417 = 2.000000e-01f * _1271416;
float _1271421;
_1271421 = 2.500000e-01f * _1271363;
float _1271409;
_1271409 = 2.000000e-01f * _1271323;
float _1271423;
_1271423 = 2.500000e-01f * _1271382;
float _1271425;
_1271425 = 2.500000e-01f * _1271403;
float _1271420;
_1271420 = 0.000000e+00f + _1271419;
int _1271404;
_1271404 = _1001400_1271277.e3;
float _1271418;
_1271418 = _1271409 + _1271417;
float _1271422;
_1271422 = _1271420 + _1271421;
float _1271424;
_1271424 = _1271422 + _1271423;
float _1271426;
_1271426 = _1271424 + _1271425;
int _1271405;
_1271405 = gid_y_1271300 * _1271404;
float val_1271427;
val_1271427 = _1271418 + _1271426;
int _1271406;
_1271406 = _1271405 + gid_x_1271314;
int _1271407;
_1271407 = 128 + _1271406;
float* idx_1271408;
idx_1271408 = _1001398_1271275 + _1271407;
*idx_1271408 = val_1271427;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1006297(struct_Img_220118 _1006300_1269958, struct_Img_220118 _1006301_1269959, float* _1006302_1269960, struct_Img_220118 _1006303_1269961, float* _1006304_1269962, float* _1006305_1269963) {
int _1269966;
int p_1269966;
int _1269969;
int p_1269969;
int _1269972;
int p_1269972;
int _1269975;
int p_1269975;
int _1269978;
int p_1269978;
int _1269981;
int p_1269981;
int _1269984;
int p_1269984;
float _1269997;
float p_1269997;
float _1270011;
float p_1270011;
float _1270016;
float p_1270016;
float _1270021;
float p_1270021;
float _1270029;
float p_1270029;
_1269966 = threadIdx_x();
p_1269966 = _1269966;
l1269964: ;
_1269966 = p_1269966;
_1269969 = blockDim_x();
p_1269969 = _1269969;
l1269967: ;
_1269969 = p_1269969;
_1269972 = blockIdx_x();
p_1269972 = _1269972;
l1269970: ;
_1269972 = p_1269972;
_1269975 = threadIdx_y();
p_1269975 = _1269975;
l1269973: ;
_1269975 = p_1269975;
_1269978 = blockDim_y();
p_1269978 = _1269978;
l1269976: ;
_1269978 = p_1269978;
_1269981 = blockIdx_y();
p_1269981 = _1269981;
l1269979: ;
_1269981 = p_1269981;
_1269984 = blockDim_y();
p_1269984 = _1269984;
l1269982: ;
_1269984 = p_1269984;
int _1269990;
_1269990 = _1269969 * _1269972;
int _1269985;
_1269985 = _1269978 * _1269981;
int gid_x_1269991;
gid_x_1269991 = _1269966 + _1269990;
int _1269988;
_1269988 = _1006301_1269959.e3;
int gid_y_1269986;
gid_y_1269986 = _1269975 + _1269985;
int _1269987;
_1269987 = 1 + gid_y_1269986;
int _1269989;
_1269989 = _1269987 * _1269988;
int _1269992;
_1269992 = _1269989 + gid_x_1269991;
int _1269993;
_1269993 = 128 + _1269992;
float* idx_1269994;
idx_1269994 = _1006302_1269960 + _1269993;
_1269997 = __ldg(idx_1269994);
p_1269997 = _1269997;
l1269995: ;
_1269997 = p_1269997;
int _1269998;
_1269998 = _1006303_1269961.e3;
int _1270005;
_1270005 = gid_y_1269986 * _1269988;
int _1269999;
_1269999 = _1269987 * _1269998;
int _1270006;
_1270006 = _1270005 + gid_x_1269991;
int _1270000;
_1270000 = _1269999 + gid_x_1269991;
int _1270007;
_1270007 = 128 + _1270006;
int _1270001;
_1270001 = 128 + _1270000;
float* idx_1270008;
idx_1270008 = _1006302_1269960 + _1270007;
float* idx_1270002;
idx_1270002 = _1006305_1269963 + _1270001;
float _1270003;
_1270003 = *idx_1270002;
_1270011 = __ldg(idx_1270008);
p_1270011 = _1270011;
l1270009: ;
_1270011 = p_1270011;
int _1270012;
_1270012 = 127 + _1269992;
float* idx_1270013;
idx_1270013 = _1006302_1269960 + _1270012;
_1270016 = __ldg(idx_1270013);
p_1270016 = _1270016;
l1270014: ;
_1270016 = p_1270016;
int _1270017;
_1270017 = 129 + _1269992;
float* idx_1270018;
idx_1270018 = _1006302_1269960 + _1270017;
_1270021 = __ldg(idx_1270018);
p_1270021 = _1270021;
l1270019: ;
_1270021 = p_1270021;
int _1270022;
_1270022 = 2 + gid_y_1269986;
int _1270023;
_1270023 = _1270022 * _1269988;
int _1270024;
_1270024 = _1270023 + gid_x_1269991;
int _1270025;
_1270025 = 128 + _1270024;
float* idx_1270026;
idx_1270026 = _1006302_1269960 + _1270025;
_1270029 = __ldg(idx_1270026);
p_1270029 = _1270029;
l1270027: ;
_1270029 = p_1270029;
float _1270041;
_1270041 = 2.500000e-01f * _1270016;
float _1270043;
_1270043 = 2.500000e-01f * _1270021;
float _1270035;
_1270035 = 2.000000e-01f * _1269997;
int _1270030;
_1270030 = _1006300_1269958.e3;
float _1270039;
_1270039 = 2.500000e-01f * _1270011;
float _1270036;
_1270036 = _1270003;
float _1270045;
_1270045 = 2.500000e-01f * _1270029;
int _1270031;
_1270031 = _1269987 * _1270030;
float _1270040;
_1270040 = 0.000000e+00f + _1270039;
float _1270037;
_1270037 = 2.000000e-01f * _1270036;
int _1270032;
_1270032 = _1270031 + gid_x_1269991;
float _1270042;
_1270042 = _1270040 + _1270041;
float _1270038;
_1270038 = _1270035 + _1270037;
int _1270033;
_1270033 = 128 + _1270032;
float _1270044;
_1270044 = _1270042 + _1270043;
float* idx_1270034;
idx_1270034 = _1006304_1269962 + _1270033;
float _1270046;
_1270046 = _1270044 + _1270045;
float val_1270047;
val_1270047 = _1270038 + _1270046;
*idx_1270034 = val_1270047;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1033592(float* _1033595_1266337, struct_Img_220118 _1033596_1266338, float* _1033597_1266339, struct_Img_220118 _1033598_1266340, struct_Img_220118 _1033599_1266341, float* _1033600_1266342) {
int _1266345;
int p_1266345;
int _1266348;
int p_1266348;
int _1266351;
int p_1266351;
int _1266354;
int p_1266354;
int _1266357;
int p_1266357;
int _1266360;
int p_1266360;
int _1266363;
int p_1266363;
struct_BoundaryMode_220129 bh_lower_1266370;
struct_BoundaryMode_220129 pbh_lower_1266370;
float _1266385;
float p_1266385;
float _1266388;
float p_1266388;
struct_BoundaryMode_220129 bh_lower_1266392;
struct_BoundaryMode_220129 pbh_lower_1266392;
float _1266403;
float p_1266403;
float _1266406;
float p_1266406;
struct_BoundaryMode_220129 bh_lower_1266412;
struct_BoundaryMode_220129 pbh_lower_1266412;
float _1266422;
float p_1266422;
float _1266425;
float p_1266425;
struct_BoundaryMode_220129 bh_lower_1266431;
struct_BoundaryMode_220129 pbh_lower_1266431;
float _1266441;
float p_1266441;
float _1266444;
float p_1266444;
struct_BoundaryMode_220129 bh_lower_1266448;
struct_BoundaryMode_220129 pbh_lower_1266448;
float _1266460;
float p_1266460;
float _1266463;
float p_1266463;
_1266345 = threadIdx_x();
p_1266345 = _1266345;
l1266343: ;
_1266345 = p_1266345;
_1266348 = blockDim_x();
p_1266348 = _1266348;
l1266346: ;
_1266348 = p_1266348;
_1266351 = blockIdx_x();
p_1266351 = _1266351;
l1266349: ;
_1266351 = p_1266351;
_1266354 = threadIdx_y();
p_1266354 = _1266354;
l1266352: ;
_1266354 = p_1266354;
_1266357 = blockDim_y();
p_1266357 = _1266357;
l1266355: ;
_1266357 = p_1266357;
_1266360 = blockIdx_y();
p_1266360 = _1266360;
l1266358: ;
_1266360 = p_1266360;
_1266363 = blockDim_y();
p_1266363 = _1266363;
l1266361: ;
_1266363 = p_1266363;
int _1266364;
_1266364 = _1266348 * _1266351;
int gid_x_1266365;
gid_x_1266365 = _1266345 + _1266364;
union variant_220130 _1266493;
_1266493.qs32 = gid_x_1266365;
bool _1266366;
_1266366 = gid_x_1266365 < 0;
struct_BoundaryMode_220129 _1266494;
_1266494.e0 = 0;
_1266494.e1 = _1266493;
if (_1266366) goto l1266367; else goto l1266523;
l1266523: ;
pbh_lower_1266370 = _1266494;
goto l1266368;
l1266367: ;
union variant_220130 _1265919_2889;
_1265919_2889.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2891;
_1265920_2891.e0 = 1;
_1265920_2891.e1 = _1265919_2889;
pbh_lower_1266370 = _1265920_2891;
goto l1266368;
l1266368: ;
bh_lower_1266370 = pbh_lower_1266370;
int _1266374;
_1266374 = _1266357 * _1266360;
int gid_y_1266375;
gid_y_1266375 = _1266354 + _1266374;
int _1266377;
_1266377 = _1033598_1266340.e3;
unsigned int _1266371;
_1266371 = bh_lower_1266370.e0;
union variant_220130 _1266379;
_1266379 = bh_lower_1266370.e1;
int _1266376;
_1266376 = 1 + gid_y_1266375;
int _1266378;
_1266378 = _1266376 * _1266377;
bool _1266372;
_1266372 = _1266371 == 0;
if (_1266372) goto l1266373; else goto l1266518;
l1266518: ;
bool _1266519;
_1266519 = _1266371 == 1;
if (_1266519) goto l1266520; else goto l1266522;
l1266522: ;
// bottom: float r4_1265918_2901;
// bottom: p_1266388 = r4_1265918_2901;
goto l1266386;
l1266520: ;
float c_1266521;
c_1266521 = _1266379.pf32;
p_1266388 = c_1266521;
goto l1266386;
l1266373: ;
int x_1266380;
x_1266380 = _1266379.qs32;
int _1266381;
_1266381 = _1266378 + x_1266380;
float* idx_1266382;
idx_1266382 = _1033597_1266339 + _1266381;
_1266385 = __ldg(idx_1266382);
p_1266385 = _1266385;
l1266383: ;
_1266385 = p_1266385;
p_1266388 = _1266385;
goto l1266386;
l1266386: ;
_1266388 = p_1266388;
int _1266469;
_1266469 = _1033596_1266338.e3;
int _1266470;
_1266470 = _1266376 * _1266469;
int _1266471;
_1266471 = _1266470 + gid_x_1266365;
float* idx_1266472;
idx_1266472 = _1033600_1266342 + _1266471;
float _1266473;
_1266473 = *idx_1266472;
if (_1266366) goto l1266389; else goto l1266517;
l1266517: ;
pbh_lower_1266392 = _1266494;
goto l1266390;
l1266389: ;
union variant_220130 _1265919_2903;
_1265919_2903.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2905;
_1265920_2905.e0 = 1;
_1265920_2905.e1 = _1265919_2903;
pbh_lower_1266392 = _1265920_2905;
goto l1266390;
l1266390: ;
bh_lower_1266392 = pbh_lower_1266392;
unsigned int _1266393;
_1266393 = bh_lower_1266392.e0;
bool _1266394;
_1266394 = _1266393 == 0;
union variant_220130 _1266397;
_1266397 = bh_lower_1266392.e1;
if (_1266394) goto l1266395; else goto l1266511;
l1266511: ;
bool _1266512;
_1266512 = _1266393 == 1;
if (_1266512) goto l1266513; else goto l1266515;
l1266515: ;
// bottom: float r4_1265918_2913;
// bottom: p_1266406 = r4_1265918_2913;
goto l1266404;
l1266513: ;
float c_1266514;
c_1266514 = _1266397.pf32;
p_1266406 = c_1266514;
goto l1266404;
l1266395: ;
int x_1266398;
x_1266398 = _1266397.qs32;
int _1266396;
_1266396 = gid_y_1266375 * _1266377;
int _1266399;
_1266399 = _1266396 + x_1266398;
float* idx_1266400;
idx_1266400 = _1033597_1266339 + _1266399;
_1266403 = __ldg(idx_1266400);
p_1266403 = _1266403;
l1266401: ;
_1266403 = p_1266403;
p_1266406 = _1266403;
goto l1266404;
l1266404: ;
_1266406 = p_1266406;
int _1266407;
_1266407 = -1 + gid_x_1266365;
bool _1266408;
_1266408 = _1266407 < 0;
if (_1266408) goto l1266409; else goto l1266508;
l1266508: ;
union variant_220130 _1266509;
_1266509.qs32 = _1266407;
struct_BoundaryMode_220129 _1266510;
_1266510.e0 = 0;
_1266510.e1 = _1266509;
pbh_lower_1266412 = _1266510;
goto l1266410;
l1266409: ;
union variant_220130 _1265919_2919;
_1265919_2919.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2921;
_1265920_2921.e0 = 1;
_1265920_2921.e1 = _1265919_2919;
pbh_lower_1266412 = _1265920_2921;
goto l1266410;
l1266410: ;
bh_lower_1266412 = pbh_lower_1266412;
union variant_220130 _1266416;
_1266416 = bh_lower_1266412.e1;
unsigned int _1266413;
_1266413 = bh_lower_1266412.e0;
bool _1266414;
_1266414 = _1266413 == 0;
if (_1266414) goto l1266415; else goto l1266503;
l1266503: ;
bool _1266504;
_1266504 = _1266413 == 1;
if (_1266504) goto l1266505; else goto l1266507;
l1266507: ;
// bottom: float r4_1265918_2929;
// bottom: p_1266425 = r4_1265918_2929;
goto l1266423;
l1266505: ;
float c_1266506;
c_1266506 = _1266416.pf32;
p_1266425 = c_1266506;
goto l1266423;
l1266415: ;
int x_1266417;
x_1266417 = _1266416.qs32;
int _1266418;
_1266418 = _1266378 + x_1266417;
float* idx_1266419;
idx_1266419 = _1033597_1266339 + _1266418;
_1266422 = __ldg(idx_1266419);
p_1266422 = _1266422;
l1266420: ;
_1266422 = p_1266422;
p_1266425 = _1266422;
goto l1266423;
l1266423: ;
_1266425 = p_1266425;
int _1266426;
_1266426 = 1 + gid_x_1266365;
bool _1266427;
_1266427 = _1266426 < 0;
if (_1266427) goto l1266428; else goto l1266500;
l1266500: ;
union variant_220130 _1266501;
_1266501.qs32 = _1266426;
struct_BoundaryMode_220129 _1266502;
_1266502.e0 = 0;
_1266502.e1 = _1266501;
pbh_lower_1266431 = _1266502;
goto l1266429;
l1266428: ;
union variant_220130 _1265919_2935;
_1265919_2935.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2937;
_1265920_2937.e0 = 1;
_1265920_2937.e1 = _1265919_2935;
pbh_lower_1266431 = _1265920_2937;
goto l1266429;
l1266429: ;
bh_lower_1266431 = pbh_lower_1266431;
unsigned int _1266432;
_1266432 = bh_lower_1266431.e0;
union variant_220130 _1266435;
_1266435 = bh_lower_1266431.e1;
bool _1266433;
_1266433 = _1266432 == 0;
if (_1266433) goto l1266434; else goto l1266495;
l1266495: ;
bool _1266496;
_1266496 = _1266432 == 1;
if (_1266496) goto l1266497; else goto l1266499;
l1266499: ;
// bottom: float r4_1265918_2945;
// bottom: p_1266444 = r4_1265918_2945;
goto l1266442;
l1266497: ;
float c_1266498;
c_1266498 = _1266435.pf32;
p_1266444 = c_1266498;
goto l1266442;
l1266434: ;
int x_1266436;
x_1266436 = _1266435.qs32;
int _1266437;
_1266437 = _1266378 + x_1266436;
float* idx_1266438;
idx_1266438 = _1033597_1266339 + _1266437;
_1266441 = __ldg(idx_1266438);
p_1266441 = _1266441;
l1266439: ;
_1266441 = p_1266441;
p_1266444 = _1266441;
goto l1266442;
l1266442: ;
_1266444 = p_1266444;
if (_1266366) goto l1266445; else goto l1266492;
l1266492: ;
pbh_lower_1266448 = _1266494;
goto l1266446;
l1266445: ;
union variant_220130 _1265919_2946;
_1265919_2946.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2948;
_1265920_2948.e0 = 1;
_1265920_2948.e1 = _1265919_2946;
pbh_lower_1266448 = _1265920_2948;
goto l1266446;
l1266446: ;
bh_lower_1266448 = pbh_lower_1266448;
union variant_220130 _1266454;
_1266454 = bh_lower_1266448.e1;
unsigned int _1266449;
_1266449 = bh_lower_1266448.e0;
bool _1266450;
_1266450 = _1266449 == 0;
if (_1266450) goto l1266451; else goto l1266487;
l1266487: ;
bool _1266488;
_1266488 = _1266449 == 1;
if (_1266488) goto l1266489; else goto l1266491;
l1266491: ;
// bottom: float r4_1265918_2956;
// bottom: p_1266463 = r4_1265918_2956;
goto l1266461;
l1266489: ;
float c_1266490;
c_1266490 = _1266454.pf32;
p_1266463 = c_1266490;
goto l1266461;
l1266451: ;
int _1266452;
_1266452 = 2 + gid_y_1266375;
int _1266453;
_1266453 = _1266452 * _1266377;
int x_1266455;
x_1266455 = _1266454.qs32;
int _1266456;
_1266456 = _1266453 + x_1266455;
float* idx_1266457;
idx_1266457 = _1033597_1266339 + _1266456;
_1266460 = __ldg(idx_1266457);
p_1266460 = _1266460;
l1266458: ;
_1266460 = p_1266460;
p_1266463 = _1266460;
goto l1266461;
l1266461: ;
_1266463 = p_1266463;
float _1266468;
_1266468 = 2.000000e-01f * _1266388;
float _1266474;
_1266474 = _1266473;
float _1266477;
_1266477 = 2.500000e-01f * _1266406;
float _1266478;
_1266478 = 0.000000e+00f + _1266477;
float _1266483;
_1266483 = 2.500000e-01f * _1266463;
int _1266464;
_1266464 = _1033599_1266341.e3;
float _1266479;
_1266479 = 2.500000e-01f * _1266425;
float _1266481;
_1266481 = 2.500000e-01f * _1266444;
float _1266475;
_1266475 = 2.000000e-01f * _1266474;
float _1266480;
_1266480 = _1266478 + _1266479;
float _1266476;
_1266476 = _1266468 + _1266475;
int _1266465;
_1266465 = _1266376 * _1266464;
float _1266482;
_1266482 = _1266480 + _1266481;
int _1266466;
_1266466 = _1266465 + gid_x_1266365;
float _1266484;
_1266484 = _1266482 + _1266483;
float* idx_1266467;
idx_1266467 = _1033595_1266337 + _1266466;
float val_1266485;
val_1266485 = _1266476 + _1266484;
*idx_1266467 = val_1266485;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1003694(struct_Img_220118 _1003697_1268590, float* _1003698_1268591, struct_Img_220118 _1003699_1268592, float* _1003700_1268593, float* _1003701_1268594, struct_Img_220118 _1003702_1268595) {
int _1268598;
int p_1268598;
int _1268601;
int p_1268601;
int _1268604;
int p_1268604;
int _1268607;
int p_1268607;
int _1268610;
int p_1268610;
int _1268613;
int p_1268613;
int _1268616;
int p_1268616;
struct_BoundaryMode_220129 bh_upper_1268627;
struct_BoundaryMode_220129 pbh_upper_1268627;
struct_BoundaryMode_220129 bh_upper_1268638;
struct_BoundaryMode_220129 pbh_upper_1268638;
float _1268655;
float p_1268655;
float _1268658;
float p_1268658;
struct_BoundaryMode_220129 bh_upper_1268662;
struct_BoundaryMode_220129 pbh_upper_1268662;
struct_BoundaryMode_220129 bh_upper_1268668;
struct_BoundaryMode_220129 pbh_upper_1268668;
float _1268684;
float p_1268684;
float _1268687;
float p_1268687;
struct_BoundaryMode_220129 bh_upper_1268693;
struct_BoundaryMode_220129 pbh_upper_1268693;
struct_BoundaryMode_220129 bh_upper_1268697;
struct_BoundaryMode_220129 pbh_upper_1268697;
float _1268713;
float p_1268713;
float _1268716;
float p_1268716;
struct_BoundaryMode_220129 bh_upper_1268722;
struct_BoundaryMode_220129 pbh_upper_1268722;
struct_BoundaryMode_220129 bh_upper_1268726;
struct_BoundaryMode_220129 pbh_upper_1268726;
float _1268742;
float p_1268742;
float _1268745;
float p_1268745;
struct_BoundaryMode_220129 bh_upper_1268749;
struct_BoundaryMode_220129 pbh_upper_1268749;
struct_BoundaryMode_220129 bh_upper_1268755;
struct_BoundaryMode_220129 pbh_upper_1268755;
float _1268771;
float p_1268771;
float _1268774;
float p_1268774;
_1268598 = threadIdx_x();
p_1268598 = _1268598;
l1268596: ;
_1268598 = p_1268598;
_1268601 = blockDim_x();
p_1268601 = _1268601;
l1268599: ;
_1268601 = p_1268601;
_1268604 = blockIdx_x();
p_1268604 = _1268604;
l1268602: ;
_1268604 = p_1268604;
_1268607 = threadIdx_y();
p_1268607 = _1268607;
l1268605: ;
_1268607 = p_1268607;
_1268610 = blockDim_y();
p_1268610 = _1268610;
l1268608: ;
_1268610 = p_1268610;
_1268613 = blockIdx_y();
p_1268613 = _1268613;
l1268611: ;
_1268613 = p_1268613;
_1268616 = blockDim_y();
p_1268616 = _1268616;
l1268614: ;
_1268616 = p_1268616;
int _1268621;
_1268621 = _1268601 * _1268604;
int _1268618;
_1268618 = _1003702_1268595.e1;
int _1268617;
_1268617 = _1003697_1268590.e1;
int _1268619;
_1268619 = _1268618 - 128;
int _1268620;
_1268620 = _1268619 + _1268598;
int gid_x_1268622;
gid_x_1268622 = _1268620 + _1268621;
union variant_220130 _1268811;
_1268811.qs32 = gid_x_1268622;
bool _1268623;
_1268623 = _1268617 <= gid_x_1268622;
struct_BoundaryMode_220129 _1268812;
_1268812.e0 = 0;
_1268812.e1 = _1268811;
if (_1268623) goto l1268624; else goto l1268865;
l1268865: ;
pbh_upper_1268627 = _1268812;
goto l1268625;
l1268624: ;
union variant_220130 _1265919_2972;
_1265919_2972.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2974;
_1265920_2974.e0 = 1;
_1265920_2974.e1 = _1265919_2972;
pbh_upper_1268627 = _1265920_2974;
goto l1268625;
l1268625: ;
bh_upper_1268627 = pbh_upper_1268627;
int _1268628;
_1268628 = _1003697_1268590.e2;
int _1268629;
_1268629 = _1003702_1268595.e2;
int _1268632;
_1268632 = _1268610 * _1268613;
int _1268630;
_1268630 = _1268629 - 1;
int _1268631;
_1268631 = _1268630 + _1268607;
int gid_y_1268633;
gid_y_1268633 = _1268631 + _1268632;
bool _1268634;
_1268634 = _1268628 <= gid_y_1268633;
union variant_220130 _1268823;
_1268823.qs32 = gid_y_1268633;
struct_BoundaryMode_220129 _1268824;
_1268824.e0 = 0;
_1268824.e1 = _1268823;
if (_1268634) goto l1268635; else goto l1268864;
l1268864: ;
pbh_upper_1268638 = _1268824;
goto l1268636;
l1268635: ;
union variant_220130 _1265919_2984;
_1265919_2984.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_2986;
_1265920_2986.e0 = 1;
_1265920_2986.e1 = _1265919_2984;
pbh_upper_1268638 = _1265920_2986;
goto l1268636;
l1268636: ;
bh_upper_1268638 = pbh_upper_1268638;
int _1268647;
_1268647 = _1003697_1268590.e3;
unsigned int _1268639;
_1268639 = bh_upper_1268627.e0;
union variant_220130 _1268645;
_1268645 = bh_upper_1268638.e1;
unsigned int _1268641;
_1268641 = bh_upper_1268638.e0;
bool _1268642;
_1268642 = _1268641 == 0;
union variant_220130 _1268649;
_1268649 = bh_upper_1268627.e1;
bool _1268640;
_1268640 = _1268639 == 0;
bool _1268643;
_1268643 = _1268640 & _1268642;
if (_1268643) goto l1268644; else goto l1268855;
l1268855: ;
bool _1268856;
_1268856 = _1268639 == 1;
if (_1268856) goto l1268857; else goto l1268859;
l1268859: ;
bool _1268860;
_1268860 = _1268641 == 1;
if (_1268860) goto l1268861; else goto l1268863;
l1268863: ;
// bottom: float r4_1265918_2999;
// bottom: p_1268658 = r4_1265918_2999;
goto l1268656;
l1268861: ;
float c_1268862;
c_1268862 = _1268645.pf32;
p_1268658 = c_1268862;
goto l1268656;
l1268857: ;
float c_1268858;
c_1268858 = _1268649.pf32;
p_1268658 = c_1268858;
goto l1268656;
l1268644: ;
int x_1268650;
x_1268650 = _1268649.qs32;
int y_1268646;
y_1268646 = _1268645.qs32;
int _1268648;
_1268648 = y_1268646 * _1268647;
int _1268651;
_1268651 = _1268648 + x_1268650;
float* idx_1268652;
idx_1268652 = _1003698_1268591 + _1268651;
_1268655 = __ldg(idx_1268652);
p_1268655 = _1268655;
l1268653: ;
_1268655 = p_1268655;
p_1268658 = _1268655;
goto l1268656;
l1268656: ;
_1268658 = p_1268658;
int _1268780;
_1268780 = _1003699_1268592.e3;
int _1268781;
_1268781 = gid_y_1268633 * _1268780;
int _1268782;
_1268782 = _1268781 + gid_x_1268622;
float* idx_1268783;
idx_1268783 = _1003701_1268594 + _1268782;
float _1268784;
_1268784 = *idx_1268783;
if (_1268623) goto l1268659; else goto l1268854;
l1268854: ;
pbh_upper_1268662 = _1268812;
goto l1268660;
l1268659: ;
union variant_220130 _1265919_3001;
_1265919_3001.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3003;
_1265920_3003.e0 = 1;
_1265920_3003.e1 = _1265919_3001;
pbh_upper_1268662 = _1265920_3003;
goto l1268660;
l1268660: ;
bh_upper_1268662 = pbh_upper_1268662;
int _1268663;
_1268663 = -1 + gid_y_1268633;
bool _1268664;
_1268664 = _1268628 <= _1268663;
if (_1268664) goto l1268665; else goto l1268850;
l1268850: ;
union variant_220130 _1268851;
_1268851.qs32 = _1268663;
struct_BoundaryMode_220129 _1268852;
_1268852.e0 = 0;
_1268852.e1 = _1268851;
pbh_upper_1268668 = _1268852;
goto l1268666;
l1268665: ;
union variant_220130 _1265919_3011;
_1265919_3011.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3013;
_1265920_3013.e0 = 1;
_1265920_3013.e1 = _1265919_3011;
pbh_upper_1268668 = _1265920_3013;
goto l1268666;
l1268666: ;
bh_upper_1268668 = pbh_upper_1268668;
union variant_220130 _1268678;
_1268678 = bh_upper_1268662.e1;
union variant_220130 _1268675;
_1268675 = bh_upper_1268668.e1;
unsigned int _1268671;
_1268671 = bh_upper_1268668.e0;
unsigned int _1268669;
_1268669 = bh_upper_1268662.e0;
bool _1268672;
_1268672 = _1268671 == 0;
bool _1268670;
_1268670 = _1268669 == 0;
bool _1268673;
_1268673 = _1268670 & _1268672;
if (_1268673) goto l1268674; else goto l1268841;
l1268841: ;
bool _1268842;
_1268842 = _1268669 == 1;
if (_1268842) goto l1268843; else goto l1268845;
l1268845: ;
bool _1268846;
_1268846 = _1268671 == 1;
if (_1268846) goto l1268847; else goto l1268849;
l1268849: ;
// bottom: float r4_1265918_3025;
// bottom: p_1268687 = r4_1265918_3025;
goto l1268685;
l1268847: ;
float c_1268848;
c_1268848 = _1268675.pf32;
p_1268687 = c_1268848;
goto l1268685;
l1268843: ;
float c_1268844;
c_1268844 = _1268678.pf32;
p_1268687 = c_1268844;
goto l1268685;
l1268674: ;
int y_1268676;
y_1268676 = _1268675.qs32;
int x_1268679;
x_1268679 = _1268678.qs32;
int _1268677;
_1268677 = y_1268676 * _1268647;
int _1268680;
_1268680 = _1268677 + x_1268679;
float* idx_1268681;
idx_1268681 = _1003698_1268591 + _1268680;
_1268684 = __ldg(idx_1268681);
p_1268684 = _1268684;
l1268682: ;
_1268684 = p_1268684;
p_1268687 = _1268684;
goto l1268685;
l1268685: ;
_1268687 = p_1268687;
int _1268688;
_1268688 = -1 + gid_x_1268622;
bool _1268689;
_1268689 = _1268617 <= _1268688;
if (_1268689) goto l1268690; else goto l1268838;
l1268838: ;
union variant_220130 _1268839;
_1268839.qs32 = _1268688;
struct_BoundaryMode_220129 _1268840;
_1268840.e0 = 0;
_1268840.e1 = _1268839;
pbh_upper_1268693 = _1268840;
goto l1268691;
l1268690: ;
union variant_220130 _1265919_3030;
_1265919_3030.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3032;
_1265920_3032.e0 = 1;
_1265920_3032.e1 = _1265919_3030;
pbh_upper_1268693 = _1265920_3032;
goto l1268691;
l1268691: ;
bh_upper_1268693 = pbh_upper_1268693;
if (_1268634) goto l1268694; else goto l1268837;
l1268837: ;
pbh_upper_1268697 = _1268824;
goto l1268695;
l1268694: ;
union variant_220130 _1265919_3036;
_1265919_3036.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3038;
_1265920_3038.e0 = 1;
_1265920_3038.e1 = _1265919_3036;
pbh_upper_1268697 = _1265920_3038;
goto l1268695;
l1268695: ;
bh_upper_1268697 = pbh_upper_1268697;
unsigned int _1268698;
_1268698 = bh_upper_1268693.e0;
bool _1268699;
_1268699 = _1268698 == 0;
union variant_220130 _1268704;
_1268704 = bh_upper_1268697.e1;
unsigned int _1268700;
_1268700 = bh_upper_1268697.e0;
union variant_220130 _1268707;
_1268707 = bh_upper_1268693.e1;
bool _1268701;
_1268701 = _1268700 == 0;
bool _1268702;
_1268702 = _1268699 & _1268701;
if (_1268702) goto l1268703; else goto l1268828;
l1268828: ;
bool _1268829;
_1268829 = _1268698 == 1;
if (_1268829) goto l1268830; else goto l1268832;
l1268832: ;
bool _1268833;
_1268833 = _1268700 == 1;
if (_1268833) goto l1268834; else goto l1268836;
l1268836: ;
// bottom: float r4_1265918_3050;
// bottom: p_1268716 = r4_1265918_3050;
goto l1268714;
l1268834: ;
float c_1268835;
c_1268835 = _1268704.pf32;
p_1268716 = c_1268835;
goto l1268714;
l1268830: ;
float c_1268831;
c_1268831 = _1268707.pf32;
p_1268716 = c_1268831;
goto l1268714;
l1268703: ;
int y_1268705;
y_1268705 = _1268704.qs32;
int x_1268708;
x_1268708 = _1268707.qs32;
int _1268706;
_1268706 = y_1268705 * _1268647;
int _1268709;
_1268709 = _1268706 + x_1268708;
float* idx_1268710;
idx_1268710 = _1003698_1268591 + _1268709;
_1268713 = __ldg(idx_1268710);
p_1268713 = _1268713;
l1268711: ;
_1268713 = p_1268713;
p_1268716 = _1268713;
goto l1268714;
l1268714: ;
_1268716 = p_1268716;
int _1268717;
_1268717 = 1 + gid_x_1268622;
bool _1268718;
_1268718 = _1268617 <= _1268717;
if (_1268718) goto l1268719; else goto l1268825;
l1268825: ;
union variant_220130 _1268826;
_1268826.qs32 = _1268717;
struct_BoundaryMode_220129 _1268827;
_1268827.e0 = 0;
_1268827.e1 = _1268826;
pbh_upper_1268722 = _1268827;
goto l1268720;
l1268719: ;
union variant_220130 _1265919_3055;
_1265919_3055.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3057;
_1265920_3057.e0 = 1;
_1265920_3057.e1 = _1265919_3055;
pbh_upper_1268722 = _1265920_3057;
goto l1268720;
l1268720: ;
bh_upper_1268722 = pbh_upper_1268722;
if (_1268634) goto l1268723; else goto l1268822;
l1268822: ;
pbh_upper_1268726 = _1268824;
goto l1268724;
l1268723: ;
union variant_220130 _1265919_3061;
_1265919_3061.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3063;
_1265920_3063.e0 = 1;
_1265920_3063.e1 = _1265919_3061;
pbh_upper_1268726 = _1265920_3063;
goto l1268724;
l1268724: ;
bh_upper_1268726 = pbh_upper_1268726;
unsigned int _1268727;
_1268727 = bh_upper_1268722.e0;
bool _1268728;
_1268728 = _1268727 == 0;
union variant_220130 _1268733;
_1268733 = bh_upper_1268726.e1;
unsigned int _1268729;
_1268729 = bh_upper_1268726.e0;
union variant_220130 _1268736;
_1268736 = bh_upper_1268722.e1;
bool _1268730;
_1268730 = _1268729 == 0;
bool _1268731;
_1268731 = _1268728 & _1268730;
if (_1268731) goto l1268732; else goto l1268813;
l1268813: ;
bool _1268814;
_1268814 = _1268727 == 1;
if (_1268814) goto l1268815; else goto l1268817;
l1268817: ;
bool _1268818;
_1268818 = _1268729 == 1;
if (_1268818) goto l1268819; else goto l1268821;
l1268821: ;
// bottom: float r4_1265918_3075;
// bottom: p_1268745 = r4_1265918_3075;
goto l1268743;
l1268819: ;
float c_1268820;
c_1268820 = _1268733.pf32;
p_1268745 = c_1268820;
goto l1268743;
l1268815: ;
float c_1268816;
c_1268816 = _1268736.pf32;
p_1268745 = c_1268816;
goto l1268743;
l1268732: ;
int y_1268734;
y_1268734 = _1268733.qs32;
int _1268735;
_1268735 = y_1268734 * _1268647;
int x_1268737;
x_1268737 = _1268736.qs32;
int _1268738;
_1268738 = _1268735 + x_1268737;
float* idx_1268739;
idx_1268739 = _1003698_1268591 + _1268738;
_1268742 = __ldg(idx_1268739);
p_1268742 = _1268742;
l1268740: ;
_1268742 = p_1268742;
p_1268745 = _1268742;
goto l1268743;
l1268743: ;
_1268745 = p_1268745;
if (_1268623) goto l1268746; else goto l1268810;
l1268810: ;
pbh_upper_1268749 = _1268812;
goto l1268747;
l1268746: ;
union variant_220130 _1265919_3076;
_1265919_3076.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3078;
_1265920_3078.e0 = 1;
_1265920_3078.e1 = _1265919_3076;
pbh_upper_1268749 = _1265920_3078;
goto l1268747;
l1268747: ;
bh_upper_1268749 = pbh_upper_1268749;
int _1268750;
_1268750 = 1 + gid_y_1268633;
bool _1268751;
_1268751 = _1268628 <= _1268750;
if (_1268751) goto l1268752; else goto l1268807;
l1268807: ;
union variant_220130 _1268808;
_1268808.qs32 = _1268750;
struct_BoundaryMode_220129 _1268809;
_1268809.e0 = 0;
_1268809.e1 = _1268808;
pbh_upper_1268755 = _1268809;
goto l1268753;
l1268752: ;
union variant_220130 _1265919_3086;
_1265919_3086.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3088;
_1265920_3088.e0 = 1;
_1265920_3088.e1 = _1265919_3086;
pbh_upper_1268755 = _1265920_3088;
goto l1268753;
l1268753: ;
bh_upper_1268755 = pbh_upper_1268755;
union variant_220130 _1268765;
_1268765 = bh_upper_1268749.e1;
union variant_220130 _1268762;
_1268762 = bh_upper_1268755.e1;
unsigned int _1268758;
_1268758 = bh_upper_1268755.e0;
unsigned int _1268756;
_1268756 = bh_upper_1268749.e0;
bool _1268759;
_1268759 = _1268758 == 0;
bool _1268757;
_1268757 = _1268756 == 0;
bool _1268760;
_1268760 = _1268757 & _1268759;
if (_1268760) goto l1268761; else goto l1268798;
l1268798: ;
bool _1268799;
_1268799 = _1268756 == 1;
if (_1268799) goto l1268800; else goto l1268802;
l1268802: ;
bool _1268803;
_1268803 = _1268758 == 1;
if (_1268803) goto l1268804; else goto l1268806;
l1268806: ;
// bottom: float r4_1265918_3100;
// bottom: p_1268774 = r4_1265918_3100;
goto l1268772;
l1268804: ;
float c_1268805;
c_1268805 = _1268762.pf32;
p_1268774 = c_1268805;
goto l1268772;
l1268800: ;
float c_1268801;
c_1268801 = _1268765.pf32;
p_1268774 = c_1268801;
goto l1268772;
l1268761: ;
int x_1268766;
x_1268766 = _1268765.qs32;
int y_1268763;
y_1268763 = _1268762.qs32;
int _1268764;
_1268764 = y_1268763 * _1268647;
int _1268767;
_1268767 = _1268764 + x_1268766;
float* idx_1268768;
idx_1268768 = _1003698_1268591 + _1268767;
_1268771 = __ldg(idx_1268768);
p_1268771 = _1268771;
l1268769: ;
_1268771 = p_1268771;
p_1268774 = _1268771;
goto l1268772;
l1268772: ;
_1268774 = p_1268774;
float _1268788;
_1268788 = 2.500000e-01f * _1268687;
float _1268789;
_1268789 = 0.000000e+00f + _1268788;
float _1268790;
_1268790 = 2.500000e-01f * _1268716;
float _1268785;
_1268785 = _1268784;
float _1268792;
_1268792 = 2.500000e-01f * _1268745;
int _1268775;
_1268775 = _1003702_1268595.e3;
float _1268779;
_1268779 = 2.000000e-01f * _1268658;
float _1268791;
_1268791 = _1268789 + _1268790;
float _1268794;
_1268794 = 2.500000e-01f * _1268774;
float _1268786;
_1268786 = 2.000000e-01f * _1268785;
float _1268793;
_1268793 = _1268791 + _1268792;
int _1268776;
_1268776 = gid_y_1268633 * _1268775;
float _1268787;
_1268787 = _1268779 + _1268786;
float _1268795;
_1268795 = _1268793 + _1268794;
int _1268777;
_1268777 = _1268776 + gid_x_1268622;
float val_1268796;
val_1268796 = _1268787 + _1268795;
float* idx_1268778;
idx_1268778 = _1003700_1268593 + _1268777;
*idx_1268778 = val_1268796;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1024819(struct_Img_220118 _1024822_1284263, float* _1024823_1284264, struct_Img_220118 _1024824_1284265, float* _1024825_1284266, float* _1024826_1284267, struct_Img_220118 _1024827_1284268) {
int _1284271;
int p_1284271;
int _1284274;
int p_1284274;
int _1284277;
int p_1284277;
int _1284280;
int p_1284280;
int _1284283;
int p_1284283;
int _1284286;
int p_1284286;
int _1284289;
int p_1284289;
struct_BoundaryMode_220129 bh_lower_1284296;
struct_BoundaryMode_220129 pbh_lower_1284296;
struct_BoundaryMode_220129 bh_upper_1284307;
struct_BoundaryMode_220129 pbh_upper_1284307;
float _1284324;
float p_1284324;
float _1284327;
float p_1284327;
struct_BoundaryMode_220129 bh_lower_1284331;
struct_BoundaryMode_220129 pbh_lower_1284331;
struct_BoundaryMode_220129 bh_upper_1284337;
struct_BoundaryMode_220129 pbh_upper_1284337;
float _1284353;
float p_1284353;
float _1284356;
float p_1284356;
struct_BoundaryMode_220129 bh_lower_1284362;
struct_BoundaryMode_220129 pbh_lower_1284362;
struct_BoundaryMode_220129 bh_upper_1284366;
struct_BoundaryMode_220129 pbh_upper_1284366;
float _1284382;
float p_1284382;
float _1284385;
float p_1284385;
struct_BoundaryMode_220129 bh_lower_1284391;
struct_BoundaryMode_220129 pbh_lower_1284391;
struct_BoundaryMode_220129 bh_upper_1284395;
struct_BoundaryMode_220129 pbh_upper_1284395;
float _1284411;
float p_1284411;
float _1284414;
float p_1284414;
struct_BoundaryMode_220129 bh_lower_1284418;
struct_BoundaryMode_220129 pbh_lower_1284418;
struct_BoundaryMode_220129 bh_upper_1284424;
struct_BoundaryMode_220129 pbh_upper_1284424;
float _1284440;
float p_1284440;
float _1284443;
float p_1284443;
_1284271 = threadIdx_x();
p_1284271 = _1284271;
l1284269: ;
_1284271 = p_1284271;
_1284274 = blockDim_x();
p_1284274 = _1284274;
l1284272: ;
_1284274 = p_1284274;
_1284277 = blockIdx_x();
p_1284277 = _1284277;
l1284275: ;
_1284277 = p_1284277;
_1284280 = threadIdx_y();
p_1284280 = _1284280;
l1284278: ;
_1284280 = p_1284280;
_1284283 = blockDim_y();
p_1284283 = _1284283;
l1284281: ;
_1284283 = p_1284283;
_1284286 = blockIdx_y();
p_1284286 = _1284286;
l1284284: ;
_1284286 = p_1284286;
_1284289 = blockDim_y();
p_1284289 = _1284289;
l1284287: ;
_1284289 = p_1284289;
int _1284290;
_1284290 = _1284274 * _1284277;
int gid_x_1284291;
gid_x_1284291 = _1284271 + _1284290;
union variant_220130 _1284480;
_1284480.qs32 = gid_x_1284291;
bool _1284292;
_1284292 = gid_x_1284291 < 0;
struct_BoundaryMode_220129 _1284481;
_1284481.e0 = 0;
_1284481.e1 = _1284480;
if (_1284292) goto l1284293; else goto l1284534;
l1284534: ;
pbh_lower_1284296 = _1284481;
goto l1284294;
l1284293: ;
union variant_220130 _1265919_3113;
_1265919_3113.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3115;
_1265920_3115.e0 = 1;
_1265920_3115.e1 = _1265919_3113;
pbh_lower_1284296 = _1265920_3115;
goto l1284294;
l1284294: ;
bh_lower_1284296 = pbh_lower_1284296;
int _1284298;
_1284298 = _1024824_1284265.e2;
int _1284301;
_1284301 = _1284283 * _1284286;
int _1284297;
_1284297 = _1024822_1284263.e2;
int _1284299;
_1284299 = _1284298 - 1;
int _1284300;
_1284300 = _1284299 + _1284280;
int gid_y_1284302;
gid_y_1284302 = _1284300 + _1284301;
bool _1284303;
_1284303 = _1284297 <= gid_y_1284302;
union variant_220130 _1284492;
_1284492.qs32 = gid_y_1284302;
struct_BoundaryMode_220129 _1284493;
_1284493.e0 = 0;
_1284493.e1 = _1284492;
if (_1284303) goto l1284304; else goto l1284533;
l1284533: ;
pbh_upper_1284307 = _1284493;
goto l1284305;
l1284304: ;
union variant_220130 _1265919_3125;
_1265919_3125.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3127;
_1265920_3127.e0 = 1;
_1265920_3127.e1 = _1265919_3125;
pbh_upper_1284307 = _1265920_3127;
goto l1284305;
l1284305: ;
bh_upper_1284307 = pbh_upper_1284307;
unsigned int _1284310;
_1284310 = bh_upper_1284307.e0;
union variant_220130 _1284318;
_1284318 = bh_lower_1284296.e1;
bool _1284311;
_1284311 = _1284310 == 0;
union variant_220130 _1284314;
_1284314 = bh_upper_1284307.e1;
unsigned int _1284308;
_1284308 = bh_lower_1284296.e0;
int _1284316;
_1284316 = _1024822_1284263.e3;
bool _1284309;
_1284309 = _1284308 == 0;
bool _1284312;
_1284312 = _1284309 & _1284311;
if (_1284312) goto l1284313; else goto l1284524;
l1284524: ;
bool _1284525;
_1284525 = _1284308 == 1;
if (_1284525) goto l1284526; else goto l1284528;
l1284528: ;
bool _1284529;
_1284529 = _1284310 == 1;
if (_1284529) goto l1284530; else goto l1284532;
l1284532: ;
// bottom: float r4_1265918_3140;
// bottom: p_1284327 = r4_1265918_3140;
goto l1284325;
l1284530: ;
float c_1284531;
c_1284531 = _1284314.pf32;
p_1284327 = c_1284531;
goto l1284325;
l1284526: ;
float c_1284527;
c_1284527 = _1284318.pf32;
p_1284327 = c_1284527;
goto l1284325;
l1284313: ;
int y_1284315;
y_1284315 = _1284314.qs32;
int x_1284319;
x_1284319 = _1284318.qs32;
int _1284317;
_1284317 = y_1284315 * _1284316;
int _1284320;
_1284320 = _1284317 + x_1284319;
float* idx_1284321;
idx_1284321 = _1024825_1284266 + _1284320;
_1284324 = __ldg(idx_1284321);
p_1284324 = _1284324;
l1284322: ;
_1284324 = p_1284324;
p_1284327 = _1284324;
goto l1284325;
l1284325: ;
_1284327 = p_1284327;
int _1284449;
_1284449 = _1024827_1284268.e3;
int _1284450;
_1284450 = gid_y_1284302 * _1284449;
int _1284451;
_1284451 = _1284450 + gid_x_1284291;
float* idx_1284452;
idx_1284452 = _1024823_1284264 + _1284451;
float _1284453;
_1284453 = *idx_1284452;
if (_1284292) goto l1284328; else goto l1284523;
l1284523: ;
pbh_lower_1284331 = _1284481;
goto l1284329;
l1284328: ;
union variant_220130 _1265919_3142;
_1265919_3142.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3144;
_1265920_3144.e0 = 1;
_1265920_3144.e1 = _1265919_3142;
pbh_lower_1284331 = _1265920_3144;
goto l1284329;
l1284329: ;
bh_lower_1284331 = pbh_lower_1284331;
int _1284332;
_1284332 = -1 + gid_y_1284302;
bool _1284333;
_1284333 = _1284297 <= _1284332;
if (_1284333) goto l1284334; else goto l1284519;
l1284519: ;
union variant_220130 _1284520;
_1284520.qs32 = _1284332;
struct_BoundaryMode_220129 _1284521;
_1284521.e0 = 0;
_1284521.e1 = _1284520;
pbh_upper_1284337 = _1284521;
goto l1284335;
l1284334: ;
union variant_220130 _1265919_3152;
_1265919_3152.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3154;
_1265920_3154.e0 = 1;
_1265920_3154.e1 = _1265919_3152;
pbh_upper_1284337 = _1265920_3154;
goto l1284335;
l1284335: ;
bh_upper_1284337 = pbh_upper_1284337;
union variant_220130 _1284344;
_1284344 = bh_upper_1284337.e1;
unsigned int _1284338;
_1284338 = bh_lower_1284331.e0;
unsigned int _1284340;
_1284340 = bh_upper_1284337.e0;
union variant_220130 _1284347;
_1284347 = bh_lower_1284331.e1;
bool _1284339;
_1284339 = _1284338 == 0;
bool _1284341;
_1284341 = _1284340 == 0;
bool _1284342;
_1284342 = _1284339 & _1284341;
if (_1284342) goto l1284343; else goto l1284510;
l1284510: ;
bool _1284511;
_1284511 = _1284338 == 1;
if (_1284511) goto l1284512; else goto l1284514;
l1284514: ;
bool _1284515;
_1284515 = _1284340 == 1;
if (_1284515) goto l1284516; else goto l1284518;
l1284518: ;
// bottom: float r4_1265918_3166;
// bottom: p_1284356 = r4_1265918_3166;
goto l1284354;
l1284516: ;
float c_1284517;
c_1284517 = _1284344.pf32;
p_1284356 = c_1284517;
goto l1284354;
l1284512: ;
float c_1284513;
c_1284513 = _1284347.pf32;
p_1284356 = c_1284513;
goto l1284354;
l1284343: ;
int x_1284348;
x_1284348 = _1284347.qs32;
int y_1284345;
y_1284345 = _1284344.qs32;
int _1284346;
_1284346 = y_1284345 * _1284316;
int _1284349;
_1284349 = _1284346 + x_1284348;
float* idx_1284350;
idx_1284350 = _1024825_1284266 + _1284349;
_1284353 = __ldg(idx_1284350);
p_1284353 = _1284353;
l1284351: ;
_1284353 = p_1284353;
p_1284356 = _1284353;
goto l1284354;
l1284354: ;
_1284356 = p_1284356;
int _1284357;
_1284357 = -1 + gid_x_1284291;
bool _1284358;
_1284358 = _1284357 < 0;
if (_1284358) goto l1284359; else goto l1284507;
l1284507: ;
union variant_220130 _1284508;
_1284508.qs32 = _1284357;
struct_BoundaryMode_220129 _1284509;
_1284509.e0 = 0;
_1284509.e1 = _1284508;
pbh_lower_1284362 = _1284509;
goto l1284360;
l1284359: ;
union variant_220130 _1265919_3172;
_1265919_3172.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3174;
_1265920_3174.e0 = 1;
_1265920_3174.e1 = _1265919_3172;
pbh_lower_1284362 = _1265920_3174;
goto l1284360;
l1284360: ;
bh_lower_1284362 = pbh_lower_1284362;
if (_1284303) goto l1284363; else goto l1284506;
l1284506: ;
pbh_upper_1284366 = _1284493;
goto l1284364;
l1284363: ;
union variant_220130 _1265919_3178;
_1265919_3178.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3180;
_1265920_3180.e0 = 1;
_1265920_3180.e1 = _1265919_3178;
pbh_upper_1284366 = _1265920_3180;
goto l1284364;
l1284364: ;
bh_upper_1284366 = pbh_upper_1284366;
unsigned int _1284369;
_1284369 = bh_upper_1284366.e0;
union variant_220130 _1284373;
_1284373 = bh_upper_1284366.e1;
union variant_220130 _1284376;
_1284376 = bh_lower_1284362.e1;
unsigned int _1284367;
_1284367 = bh_lower_1284362.e0;
bool _1284368;
_1284368 = _1284367 == 0;
bool _1284370;
_1284370 = _1284369 == 0;
bool _1284371;
_1284371 = _1284368 & _1284370;
if (_1284371) goto l1284372; else goto l1284497;
l1284497: ;
bool _1284498;
_1284498 = _1284367 == 1;
if (_1284498) goto l1284499; else goto l1284501;
l1284501: ;
bool _1284502;
_1284502 = _1284369 == 1;
if (_1284502) goto l1284503; else goto l1284505;
l1284505: ;
// bottom: float r4_1265918_3192;
// bottom: p_1284385 = r4_1265918_3192;
goto l1284383;
l1284503: ;
float c_1284504;
c_1284504 = _1284373.pf32;
p_1284385 = c_1284504;
goto l1284383;
l1284499: ;
float c_1284500;
c_1284500 = _1284376.pf32;
p_1284385 = c_1284500;
goto l1284383;
l1284372: ;
int y_1284374;
y_1284374 = _1284373.qs32;
int x_1284377;
x_1284377 = _1284376.qs32;
int _1284375;
_1284375 = y_1284374 * _1284316;
int _1284378;
_1284378 = _1284375 + x_1284377;
float* idx_1284379;
idx_1284379 = _1024825_1284266 + _1284378;
_1284382 = __ldg(idx_1284379);
p_1284382 = _1284382;
l1284380: ;
_1284382 = p_1284382;
p_1284385 = _1284382;
goto l1284383;
l1284383: ;
_1284385 = p_1284385;
int _1284386;
_1284386 = 1 + gid_x_1284291;
bool _1284387;
_1284387 = _1284386 < 0;
if (_1284387) goto l1284388; else goto l1284494;
l1284494: ;
union variant_220130 _1284495;
_1284495.qs32 = _1284386;
struct_BoundaryMode_220129 _1284496;
_1284496.e0 = 0;
_1284496.e1 = _1284495;
pbh_lower_1284391 = _1284496;
goto l1284389;
l1284388: ;
union variant_220130 _1265919_3198;
_1265919_3198.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3200;
_1265920_3200.e0 = 1;
_1265920_3200.e1 = _1265919_3198;
pbh_lower_1284391 = _1265920_3200;
goto l1284389;
l1284389: ;
bh_lower_1284391 = pbh_lower_1284391;
if (_1284303) goto l1284392; else goto l1284491;
l1284491: ;
pbh_upper_1284395 = _1284493;
goto l1284393;
l1284392: ;
union variant_220130 _1265919_3204;
_1265919_3204.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3206;
_1265920_3206.e0 = 1;
_1265920_3206.e1 = _1265919_3204;
pbh_upper_1284395 = _1265920_3206;
goto l1284393;
l1284393: ;
bh_upper_1284395 = pbh_upper_1284395;
unsigned int _1284396;
_1284396 = bh_lower_1284391.e0;
unsigned int _1284398;
_1284398 = bh_upper_1284395.e0;
bool _1284397;
_1284397 = _1284396 == 0;
union variant_220130 _1284405;
_1284405 = bh_lower_1284391.e1;
union variant_220130 _1284402;
_1284402 = bh_upper_1284395.e1;
bool _1284399;
_1284399 = _1284398 == 0;
bool _1284400;
_1284400 = _1284397 & _1284399;
if (_1284400) goto l1284401; else goto l1284482;
l1284482: ;
bool _1284483;
_1284483 = _1284396 == 1;
if (_1284483) goto l1284484; else goto l1284486;
l1284486: ;
bool _1284487;
_1284487 = _1284398 == 1;
if (_1284487) goto l1284488; else goto l1284490;
l1284490: ;
// bottom: float r4_1265918_3218;
// bottom: p_1284414 = r4_1265918_3218;
goto l1284412;
l1284488: ;
float c_1284489;
c_1284489 = _1284402.pf32;
p_1284414 = c_1284489;
goto l1284412;
l1284484: ;
float c_1284485;
c_1284485 = _1284405.pf32;
p_1284414 = c_1284485;
goto l1284412;
l1284401: ;
int x_1284406;
x_1284406 = _1284405.qs32;
int y_1284403;
y_1284403 = _1284402.qs32;
int _1284404;
_1284404 = y_1284403 * _1284316;
int _1284407;
_1284407 = _1284404 + x_1284406;
float* idx_1284408;
idx_1284408 = _1024825_1284266 + _1284407;
_1284411 = __ldg(idx_1284408);
p_1284411 = _1284411;
l1284409: ;
_1284411 = p_1284411;
p_1284414 = _1284411;
goto l1284412;
l1284412: ;
_1284414 = p_1284414;
if (_1284292) goto l1284415; else goto l1284479;
l1284479: ;
pbh_lower_1284418 = _1284481;
goto l1284416;
l1284415: ;
union variant_220130 _1265919_3219;
_1265919_3219.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3221;
_1265920_3221.e0 = 1;
_1265920_3221.e1 = _1265919_3219;
pbh_lower_1284418 = _1265920_3221;
goto l1284416;
l1284416: ;
bh_lower_1284418 = pbh_lower_1284418;
int _1284419;
_1284419 = 1 + gid_y_1284302;
bool _1284420;
_1284420 = _1284297 <= _1284419;
if (_1284420) goto l1284421; else goto l1284476;
l1284476: ;
union variant_220130 _1284477;
_1284477.qs32 = _1284419;
struct_BoundaryMode_220129 _1284478;
_1284478.e0 = 0;
_1284478.e1 = _1284477;
pbh_upper_1284424 = _1284478;
goto l1284422;
l1284421: ;
union variant_220130 _1265919_3229;
_1265919_3229.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3231;
_1265920_3231.e0 = 1;
_1265920_3231.e1 = _1265919_3229;
pbh_upper_1284424 = _1265920_3231;
goto l1284422;
l1284422: ;
bh_upper_1284424 = pbh_upper_1284424;
unsigned int _1284427;
_1284427 = bh_upper_1284424.e0;
bool _1284428;
_1284428 = _1284427 == 0;
union variant_220130 _1284434;
_1284434 = bh_lower_1284418.e1;
union variant_220130 _1284431;
_1284431 = bh_upper_1284424.e1;
unsigned int _1284425;
_1284425 = bh_lower_1284418.e0;
bool _1284426;
_1284426 = _1284425 == 0;
bool _1284429;
_1284429 = _1284426 & _1284428;
if (_1284429) goto l1284430; else goto l1284467;
l1284467: ;
bool _1284468;
_1284468 = _1284425 == 1;
if (_1284468) goto l1284469; else goto l1284471;
l1284471: ;
bool _1284472;
_1284472 = _1284427 == 1;
if (_1284472) goto l1284473; else goto l1284475;
l1284475: ;
// bottom: float r4_1265918_3243;
// bottom: p_1284443 = r4_1265918_3243;
goto l1284441;
l1284473: ;
float c_1284474;
c_1284474 = _1284431.pf32;
p_1284443 = c_1284474;
goto l1284441;
l1284469: ;
float c_1284470;
c_1284470 = _1284434.pf32;
p_1284443 = c_1284470;
goto l1284441;
l1284430: ;
int y_1284432;
y_1284432 = _1284431.qs32;
int x_1284435;
x_1284435 = _1284434.qs32;
int _1284433;
_1284433 = y_1284432 * _1284316;
int _1284436;
_1284436 = _1284433 + x_1284435;
float* idx_1284437;
idx_1284437 = _1024825_1284266 + _1284436;
_1284440 = __ldg(idx_1284437);
p_1284440 = _1284440;
l1284438: ;
_1284440 = p_1284440;
p_1284443 = _1284440;
goto l1284441;
l1284441: ;
_1284443 = p_1284443;
float _1284454;
_1284454 = _1284453;
float _1284459;
_1284459 = 2.500000e-01f * _1284385;
float _1284455;
_1284455 = 2.000000e-01f * _1284454;
float _1284463;
_1284463 = 2.500000e-01f * _1284443;
float _1284448;
_1284448 = 2.000000e-01f * _1284327;
float _1284457;
_1284457 = 2.500000e-01f * _1284356;
float _1284461;
_1284461 = 2.500000e-01f * _1284414;
int _1284444;
_1284444 = _1024824_1284265.e3;
int _1284445;
_1284445 = gid_y_1284302 * _1284444;
float _1284456;
_1284456 = _1284448 + _1284455;
float _1284458;
_1284458 = 0.000000e+00f + _1284457;
int _1284446;
_1284446 = _1284445 + gid_x_1284291;
float _1284460;
_1284460 = _1284458 + _1284459;
float* idx_1284447;
idx_1284447 = _1024826_1284267 + _1284446;
float _1284462;
_1284462 = _1284460 + _1284461;
float _1284464;
_1284464 = _1284462 + _1284463;
float val_1284465;
val_1284465 = _1284456 + _1284464;
*idx_1284447 = val_1284465;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1039389(struct_Img_220118 _1039392_1284612, struct_Img_220118 _1039393_1284613, float* _1039394_1284614, struct_Img_220118 _1039395_1284615, float* _1039396_1284616, float* _1039397_1284617) {
int _1284620;
int p_1284620;
int _1284623;
int p_1284623;
int _1284626;
int p_1284626;
int _1284629;
int p_1284629;
int _1284632;
int p_1284632;
int _1284635;
int p_1284635;
int _1284638;
int p_1284638;
struct_BoundaryMode_220129 bh_lower_1284645;
struct_BoundaryMode_220129 pbh_lower_1284645;
float _1284660;
float p_1284660;
float _1284663;
float p_1284663;
struct_BoundaryMode_220129 bh_lower_1284669;
struct_BoundaryMode_220129 pbh_lower_1284669;
float _1284681;
float p_1284681;
float _1284684;
float p_1284684;
struct_BoundaryMode_220129 bh_lower_1284688;
struct_BoundaryMode_220129 pbh_lower_1284688;
float _1284700;
float p_1284700;
float _1284703;
float p_1284703;
struct_BoundaryMode_220129 bh_lower_1284707;
struct_BoundaryMode_220129 pbh_lower_1284707;
float _1284719;
float p_1284719;
float _1284722;
float p_1284722;
struct_BoundaryMode_220129 bh_lower_1284728;
struct_BoundaryMode_220129 pbh_lower_1284728;
float _1284740;
float p_1284740;
float _1284743;
float p_1284743;
_1284620 = threadIdx_x();
p_1284620 = _1284620;
l1284618: ;
_1284620 = p_1284620;
_1284623 = blockDim_x();
p_1284623 = _1284623;
l1284621: ;
_1284623 = p_1284623;
_1284626 = blockIdx_x();
p_1284626 = _1284626;
l1284624: ;
_1284626 = p_1284626;
_1284629 = threadIdx_y();
p_1284629 = _1284629;
l1284627: ;
_1284629 = p_1284629;
_1284632 = blockDim_y();
p_1284632 = _1284632;
l1284630: ;
_1284632 = p_1284632;
_1284635 = blockIdx_y();
p_1284635 = _1284635;
l1284633: ;
_1284635 = p_1284635;
_1284638 = blockDim_y();
p_1284638 = _1284638;
l1284636: ;
_1284638 = p_1284638;
int _1284639;
_1284639 = _1284632 * _1284635;
int gid_y_1284640;
gid_y_1284640 = _1284629 + _1284639;
union variant_220130 _1284783;
_1284783.qs32 = gid_y_1284640;
bool _1284641;
_1284641 = gid_y_1284640 < 0;
struct_BoundaryMode_220129 _1284784;
_1284784.e0 = 0;
_1284784.e1 = _1284783;
if (_1284641) goto l1284642; else goto l1284805;
l1284805: ;
pbh_lower_1284645 = _1284784;
goto l1284643;
l1284642: ;
union variant_220130 _1265919_3256;
_1265919_3256.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3258;
_1265920_3258.e0 = 1;
_1265920_3258.e1 = _1265919_3256;
pbh_lower_1284645 = _1265920_3258;
goto l1284643;
l1284643: ;
bh_lower_1284645 = pbh_lower_1284645;
int _1284653;
_1284653 = _1284623 * _1284626;
union variant_220130 _1284649;
_1284649 = bh_lower_1284645.e1;
int _1284651;
_1284651 = _1039392_1284612.e3;
int gid_x_1284654;
gid_x_1284654 = _1284620 + _1284653;
unsigned int _1284646;
_1284646 = bh_lower_1284645.e0;
bool _1284647;
_1284647 = _1284646 == 0;
if (_1284647) goto l1284648; else goto l1284800;
l1284800: ;
bool _1284801;
_1284801 = _1284646 == 1;
if (_1284801) goto l1284802; else goto l1284804;
l1284804: ;
// bottom: float r4_1265918_3267;
// bottom: p_1284663 = r4_1265918_3267;
goto l1284661;
l1284802: ;
float c_1284803;
c_1284803 = _1284649.pf32;
p_1284663 = c_1284803;
goto l1284661;
l1284648: ;
int y_1284650;
y_1284650 = _1284649.qs32;
int _1284652;
_1284652 = y_1284650 * _1284651;
int _1284655;
_1284655 = _1284652 + gid_x_1284654;
int _1284656;
_1284656 = 128 + _1284655;
float* idx_1284657;
idx_1284657 = _1039394_1284614 + _1284656;
_1284660 = __ldg(idx_1284657);
p_1284660 = _1284660;
l1284658: ;
_1284660 = p_1284660;
p_1284663 = _1284660;
goto l1284661;
l1284661: ;
_1284663 = p_1284663;
int _1284750;
_1284750 = _1039395_1284615.e3;
int _1284664;
_1284664 = -1 + gid_y_1284640;
int _1284751;
_1284751 = gid_y_1284640 * _1284750;
int _1284752;
_1284752 = _1284751 + gid_x_1284654;
bool _1284665;
_1284665 = _1284664 < 0;
int _1284753;
_1284753 = 128 + _1284752;
float* idx_1284754;
idx_1284754 = _1039397_1284617 + _1284753;
float _1284755;
_1284755 = *idx_1284754;
if (_1284665) goto l1284666; else goto l1284797;
l1284797: ;
union variant_220130 _1284798;
_1284798.qs32 = _1284664;
struct_BoundaryMode_220129 _1284799;
_1284799.e0 = 0;
_1284799.e1 = _1284798;
pbh_lower_1284669 = _1284799;
goto l1284667;
l1284666: ;
union variant_220130 _1265919_3276;
_1265919_3276.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3278;
_1265920_3278.e0 = 1;
_1265920_3278.e1 = _1265919_3276;
pbh_lower_1284669 = _1265920_3278;
goto l1284667;
l1284667: ;
bh_lower_1284669 = pbh_lower_1284669;
union variant_220130 _1284673;
_1284673 = bh_lower_1284669.e1;
unsigned int _1284670;
_1284670 = bh_lower_1284669.e0;
bool _1284671;
_1284671 = _1284670 == 0;
if (_1284671) goto l1284672; else goto l1284791;
l1284791: ;
bool _1284792;
_1284792 = _1284670 == 1;
if (_1284792) goto l1284793; else goto l1284795;
l1284795: ;
// bottom: float r4_1265918_3286;
// bottom: p_1284684 = r4_1265918_3286;
goto l1284682;
l1284793: ;
float c_1284794;
c_1284794 = _1284673.pf32;
p_1284684 = c_1284794;
goto l1284682;
l1284672: ;
int y_1284674;
y_1284674 = _1284673.qs32;
int _1284675;
_1284675 = y_1284674 * _1284651;
int _1284676;
_1284676 = _1284675 + gid_x_1284654;
int _1284677;
_1284677 = 128 + _1284676;
float* idx_1284678;
idx_1284678 = _1039394_1284614 + _1284677;
_1284681 = __ldg(idx_1284678);
p_1284681 = _1284681;
l1284679: ;
_1284681 = p_1284681;
p_1284684 = _1284681;
goto l1284682;
l1284682: ;
_1284684 = p_1284684;
if (_1284641) goto l1284685; else goto l1284790;
l1284790: ;
pbh_lower_1284688 = _1284784;
goto l1284686;
l1284685: ;
union variant_220130 _1265919_3288;
_1265919_3288.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3290;
_1265920_3290.e0 = 1;
_1265920_3290.e1 = _1265919_3288;
pbh_lower_1284688 = _1265920_3290;
goto l1284686;
l1284686: ;
bh_lower_1284688 = pbh_lower_1284688;
union variant_220130 _1284692;
_1284692 = bh_lower_1284688.e1;
unsigned int _1284689;
_1284689 = bh_lower_1284688.e0;
bool _1284690;
_1284690 = _1284689 == 0;
if (_1284690) goto l1284691; else goto l1284785;
l1284785: ;
bool _1284786;
_1284786 = _1284689 == 1;
if (_1284786) goto l1284787; else goto l1284789;
l1284789: ;
// bottom: float r4_1265918_3298;
// bottom: p_1284703 = r4_1265918_3298;
goto l1284701;
l1284787: ;
float c_1284788;
c_1284788 = _1284692.pf32;
p_1284703 = c_1284788;
goto l1284701;
l1284691: ;
int y_1284693;
y_1284693 = _1284692.qs32;
int _1284694;
_1284694 = y_1284693 * _1284651;
int _1284695;
_1284695 = _1284694 + gid_x_1284654;
int _1284696;
_1284696 = 127 + _1284695;
float* idx_1284697;
idx_1284697 = _1039394_1284614 + _1284696;
_1284700 = __ldg(idx_1284697);
p_1284700 = _1284700;
l1284698: ;
_1284700 = p_1284700;
p_1284703 = _1284700;
goto l1284701;
l1284701: ;
_1284703 = p_1284703;
if (_1284641) goto l1284704; else goto l1284782;
l1284782: ;
pbh_lower_1284707 = _1284784;
goto l1284705;
l1284704: ;
union variant_220130 _1265919_3300;
_1265919_3300.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3302;
_1265920_3302.e0 = 1;
_1265920_3302.e1 = _1265919_3300;
pbh_lower_1284707 = _1265920_3302;
goto l1284705;
l1284705: ;
bh_lower_1284707 = pbh_lower_1284707;
unsigned int _1284708;
_1284708 = bh_lower_1284707.e0;
union variant_220130 _1284711;
_1284711 = bh_lower_1284707.e1;
bool _1284709;
_1284709 = _1284708 == 0;
if (_1284709) goto l1284710; else goto l1284777;
l1284777: ;
bool _1284778;
_1284778 = _1284708 == 1;
if (_1284778) goto l1284779; else goto l1284781;
l1284781: ;
// bottom: float r4_1265918_3310;
// bottom: p_1284722 = r4_1265918_3310;
goto l1284720;
l1284779: ;
float c_1284780;
c_1284780 = _1284711.pf32;
p_1284722 = c_1284780;
goto l1284720;
l1284710: ;
int y_1284712;
y_1284712 = _1284711.qs32;
int _1284713;
_1284713 = y_1284712 * _1284651;
int _1284714;
_1284714 = _1284713 + gid_x_1284654;
int _1284715;
_1284715 = 129 + _1284714;
float* idx_1284716;
idx_1284716 = _1039394_1284614 + _1284715;
_1284719 = __ldg(idx_1284716);
p_1284719 = _1284719;
l1284717: ;
_1284719 = p_1284719;
p_1284722 = _1284719;
goto l1284720;
l1284720: ;
_1284722 = p_1284722;
int _1284723;
_1284723 = 1 + gid_y_1284640;
bool _1284724;
_1284724 = _1284723 < 0;
if (_1284724) goto l1284725; else goto l1284774;
l1284774: ;
union variant_220130 _1284775;
_1284775.qs32 = _1284723;
struct_BoundaryMode_220129 _1284776;
_1284776.e0 = 0;
_1284776.e1 = _1284775;
pbh_lower_1284728 = _1284776;
goto l1284726;
l1284725: ;
union variant_220130 _1265919_3317;
_1265919_3317.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3319;
_1265920_3319.e0 = 1;
_1265920_3319.e1 = _1265919_3317;
pbh_lower_1284728 = _1265920_3319;
goto l1284726;
l1284726: ;
bh_lower_1284728 = pbh_lower_1284728;
unsigned int _1284729;
_1284729 = bh_lower_1284728.e0;
union variant_220130 _1284732;
_1284732 = bh_lower_1284728.e1;
bool _1284730;
_1284730 = _1284729 == 0;
if (_1284730) goto l1284731; else goto l1284769;
l1284769: ;
bool _1284770;
_1284770 = _1284729 == 1;
if (_1284770) goto l1284771; else goto l1284773;
l1284773: ;
// bottom: float r4_1265918_3327;
// bottom: p_1284743 = r4_1265918_3327;
goto l1284741;
l1284771: ;
float c_1284772;
c_1284772 = _1284732.pf32;
p_1284743 = c_1284772;
goto l1284741;
l1284731: ;
int y_1284733;
y_1284733 = _1284732.qs32;
int _1284734;
_1284734 = y_1284733 * _1284651;
int _1284735;
_1284735 = _1284734 + gid_x_1284654;
int _1284736;
_1284736 = 128 + _1284735;
float* idx_1284737;
idx_1284737 = _1039394_1284614 + _1284736;
_1284740 = __ldg(idx_1284737);
p_1284740 = _1284740;
l1284738: ;
_1284740 = p_1284740;
p_1284743 = _1284740;
goto l1284741;
l1284741: ;
_1284743 = p_1284743;
float _1284761;
_1284761 = 2.500000e-01f * _1284703;
float _1284765;
_1284765 = 2.500000e-01f * _1284743;
float _1284763;
_1284763 = 2.500000e-01f * _1284722;
int _1284744;
_1284744 = _1039393_1284613.e3;
float _1284756;
_1284756 = _1284755;
float _1284759;
_1284759 = 2.500000e-01f * _1284684;
int _1284745;
_1284745 = gid_y_1284640 * _1284744;
float _1284749;
_1284749 = 2.000000e-01f * _1284663;
float _1284757;
_1284757 = 2.000000e-01f * _1284756;
float _1284760;
_1284760 = 0.000000e+00f + _1284759;
int _1284746;
_1284746 = _1284745 + gid_x_1284654;
float _1284758;
_1284758 = _1284749 + _1284757;
float _1284762;
_1284762 = _1284760 + _1284761;
int _1284747;
_1284747 = 128 + _1284746;
float _1284764;
_1284764 = _1284762 + _1284763;
float* idx_1284748;
idx_1284748 = _1039396_1284616 + _1284747;
float _1284766;
_1284766 = _1284764 + _1284765;
float val_1284767;
val_1284767 = _1284758 + _1284766;
*idx_1284748 = val_1284767;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1034597(float* _1034600_1280474, struct_Img_220118 _1034601_1280475, float* _1034602_1280476, struct_Img_220118 _1034603_1280477, struct_Img_220118 _1034604_1280478, float* _1034605_1280479) {
int _1280482;
int p_1280482;
int _1280485;
int p_1280485;
int _1280488;
int p_1280488;
int _1280491;
int p_1280491;
int _1280494;
int p_1280494;
int _1280497;
int p_1280497;
int _1280500;
int p_1280500;
struct_BoundaryMode_220129 bh_lower_1280507;
struct_BoundaryMode_220129 pbh_lower_1280507;
float _1280522;
float p_1280522;
float _1280525;
float p_1280525;
struct_BoundaryMode_220129 bh_lower_1280531;
struct_BoundaryMode_220129 pbh_lower_1280531;
float _1280543;
float p_1280543;
float _1280546;
float p_1280546;
struct_BoundaryMode_220129 bh_lower_1280550;
struct_BoundaryMode_220129 pbh_lower_1280550;
float _1280562;
float p_1280562;
float _1280565;
float p_1280565;
struct_BoundaryMode_220129 bh_lower_1280569;
struct_BoundaryMode_220129 pbh_lower_1280569;
float _1280581;
float p_1280581;
float _1280584;
float p_1280584;
struct_BoundaryMode_220129 bh_lower_1280590;
struct_BoundaryMode_220129 pbh_lower_1280590;
float _1280602;
float p_1280602;
float _1280605;
float p_1280605;
_1280482 = threadIdx_x();
p_1280482 = _1280482;
l1280480: ;
_1280482 = p_1280482;
_1280485 = blockDim_x();
p_1280485 = _1280485;
l1280483: ;
_1280485 = p_1280485;
_1280488 = blockIdx_x();
p_1280488 = _1280488;
l1280486: ;
_1280488 = p_1280488;
_1280491 = threadIdx_y();
p_1280491 = _1280491;
l1280489: ;
_1280491 = p_1280491;
_1280494 = blockDim_y();
p_1280494 = _1280494;
l1280492: ;
_1280494 = p_1280494;
_1280497 = blockIdx_y();
p_1280497 = _1280497;
l1280495: ;
_1280497 = p_1280497;
_1280500 = blockDim_y();
p_1280500 = _1280500;
l1280498: ;
_1280500 = p_1280500;
int _1280501;
_1280501 = _1280494 * _1280497;
int gid_y_1280502;
gid_y_1280502 = _1280491 + _1280501;
union variant_220130 _1280645;
_1280645.qs32 = gid_y_1280502;
bool _1280503;
_1280503 = gid_y_1280502 < 0;
struct_BoundaryMode_220129 _1280646;
_1280646.e0 = 0;
_1280646.e1 = _1280645;
if (_1280503) goto l1280504; else goto l1280667;
l1280667: ;
pbh_lower_1280507 = _1280646;
goto l1280505;
l1280504: ;
union variant_220130 _1265919_3342;
_1265919_3342.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3344;
_1265920_3344.e0 = 1;
_1265920_3344.e1 = _1265919_3342;
pbh_lower_1280507 = _1265920_3344;
goto l1280505;
l1280505: ;
bh_lower_1280507 = pbh_lower_1280507;
union variant_220130 _1280511;
_1280511 = bh_lower_1280507.e1;
int _1280515;
_1280515 = _1280485 * _1280488;
int _1280513;
_1280513 = _1034603_1280477.e3;
unsigned int _1280508;
_1280508 = bh_lower_1280507.e0;
int gid_x_1280516;
gid_x_1280516 = _1280482 + _1280515;
bool _1280509;
_1280509 = _1280508 == 0;
if (_1280509) goto l1280510; else goto l1280662;
l1280662: ;
bool _1280663;
_1280663 = _1280508 == 1;
if (_1280663) goto l1280664; else goto l1280666;
l1280666: ;
// bottom: float r4_1265918_3353;
// bottom: p_1280525 = r4_1265918_3353;
goto l1280523;
l1280664: ;
float c_1280665;
c_1280665 = _1280511.pf32;
p_1280525 = c_1280665;
goto l1280523;
l1280510: ;
int y_1280512;
y_1280512 = _1280511.qs32;
int _1280514;
_1280514 = y_1280512 * _1280513;
int _1280517;
_1280517 = _1280514 + gid_x_1280516;
int _1280518;
_1280518 = 128 + _1280517;
float* idx_1280519;
idx_1280519 = _1034602_1280476 + _1280518;
_1280522 = __ldg(idx_1280519);
p_1280522 = _1280522;
l1280520: ;
_1280522 = p_1280522;
p_1280525 = _1280522;
goto l1280523;
l1280523: ;
_1280525 = p_1280525;
int _1280612;
_1280612 = _1034601_1280475.e3;
int _1280526;
_1280526 = -1 + gid_y_1280502;
int _1280613;
_1280613 = gid_y_1280502 * _1280612;
bool _1280527;
_1280527 = _1280526 < 0;
int _1280614;
_1280614 = _1280613 + gid_x_1280516;
int _1280615;
_1280615 = 128 + _1280614;
float* idx_1280616;
idx_1280616 = _1034605_1280479 + _1280615;
float _1280617;
_1280617 = *idx_1280616;
if (_1280527) goto l1280528; else goto l1280659;
l1280659: ;
union variant_220130 _1280660;
_1280660.qs32 = _1280526;
struct_BoundaryMode_220129 _1280661;
_1280661.e0 = 0;
_1280661.e1 = _1280660;
pbh_lower_1280531 = _1280661;
goto l1280529;
l1280528: ;
union variant_220130 _1265919_3362;
_1265919_3362.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3364;
_1265920_3364.e0 = 1;
_1265920_3364.e1 = _1265919_3362;
pbh_lower_1280531 = _1265920_3364;
goto l1280529;
l1280529: ;
bh_lower_1280531 = pbh_lower_1280531;
unsigned int _1280532;
_1280532 = bh_lower_1280531.e0;
union variant_220130 _1280535;
_1280535 = bh_lower_1280531.e1;
bool _1280533;
_1280533 = _1280532 == 0;
if (_1280533) goto l1280534; else goto l1280653;
l1280653: ;
bool _1280654;
_1280654 = _1280532 == 1;
if (_1280654) goto l1280655; else goto l1280657;
l1280657: ;
// bottom: float r4_1265918_3372;
// bottom: p_1280546 = r4_1265918_3372;
goto l1280544;
l1280655: ;
float c_1280656;
c_1280656 = _1280535.pf32;
p_1280546 = c_1280656;
goto l1280544;
l1280534: ;
int y_1280536;
y_1280536 = _1280535.qs32;
int _1280537;
_1280537 = y_1280536 * _1280513;
int _1280538;
_1280538 = _1280537 + gid_x_1280516;
int _1280539;
_1280539 = 128 + _1280538;
float* idx_1280540;
idx_1280540 = _1034602_1280476 + _1280539;
_1280543 = __ldg(idx_1280540);
p_1280543 = _1280543;
l1280541: ;
_1280543 = p_1280543;
p_1280546 = _1280543;
goto l1280544;
l1280544: ;
_1280546 = p_1280546;
if (_1280503) goto l1280547; else goto l1280652;
l1280652: ;
pbh_lower_1280550 = _1280646;
goto l1280548;
l1280547: ;
union variant_220130 _1265919_3374;
_1265919_3374.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3376;
_1265920_3376.e0 = 1;
_1265920_3376.e1 = _1265919_3374;
pbh_lower_1280550 = _1265920_3376;
goto l1280548;
l1280548: ;
bh_lower_1280550 = pbh_lower_1280550;
unsigned int _1280551;
_1280551 = bh_lower_1280550.e0;
union variant_220130 _1280554;
_1280554 = bh_lower_1280550.e1;
bool _1280552;
_1280552 = _1280551 == 0;
if (_1280552) goto l1280553; else goto l1280647;
l1280647: ;
bool _1280648;
_1280648 = _1280551 == 1;
if (_1280648) goto l1280649; else goto l1280651;
l1280651: ;
// bottom: float r4_1265918_3384;
// bottom: p_1280565 = r4_1265918_3384;
goto l1280563;
l1280649: ;
float c_1280650;
c_1280650 = _1280554.pf32;
p_1280565 = c_1280650;
goto l1280563;
l1280553: ;
int y_1280555;
y_1280555 = _1280554.qs32;
int _1280556;
_1280556 = y_1280555 * _1280513;
int _1280557;
_1280557 = _1280556 + gid_x_1280516;
int _1280558;
_1280558 = 127 + _1280557;
float* idx_1280559;
idx_1280559 = _1034602_1280476 + _1280558;
_1280562 = __ldg(idx_1280559);
p_1280562 = _1280562;
l1280560: ;
_1280562 = p_1280562;
p_1280565 = _1280562;
goto l1280563;
l1280563: ;
_1280565 = p_1280565;
if (_1280503) goto l1280566; else goto l1280644;
l1280644: ;
pbh_lower_1280569 = _1280646;
goto l1280567;
l1280566: ;
union variant_220130 _1265919_3386;
_1265919_3386.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3388;
_1265920_3388.e0 = 1;
_1265920_3388.e1 = _1265919_3386;
pbh_lower_1280569 = _1265920_3388;
goto l1280567;
l1280567: ;
bh_lower_1280569 = pbh_lower_1280569;
unsigned int _1280570;
_1280570 = bh_lower_1280569.e0;
bool _1280571;
_1280571 = _1280570 == 0;
union variant_220130 _1280573;
_1280573 = bh_lower_1280569.e1;
if (_1280571) goto l1280572; else goto l1280639;
l1280639: ;
bool _1280640;
_1280640 = _1280570 == 1;
if (_1280640) goto l1280641; else goto l1280643;
l1280643: ;
// bottom: float r4_1265918_3396;
// bottom: p_1280584 = r4_1265918_3396;
goto l1280582;
l1280641: ;
float c_1280642;
c_1280642 = _1280573.pf32;
p_1280584 = c_1280642;
goto l1280582;
l1280572: ;
int y_1280574;
y_1280574 = _1280573.qs32;
int _1280575;
_1280575 = y_1280574 * _1280513;
int _1280576;
_1280576 = _1280575 + gid_x_1280516;
int _1280577;
_1280577 = 129 + _1280576;
float* idx_1280578;
idx_1280578 = _1034602_1280476 + _1280577;
_1280581 = __ldg(idx_1280578);
p_1280581 = _1280581;
l1280579: ;
_1280581 = p_1280581;
p_1280584 = _1280581;
goto l1280582;
l1280582: ;
_1280584 = p_1280584;
int _1280585;
_1280585 = 1 + gid_y_1280502;
bool _1280586;
_1280586 = _1280585 < 0;
if (_1280586) goto l1280587; else goto l1280636;
l1280636: ;
union variant_220130 _1280637;
_1280637.qs32 = _1280585;
struct_BoundaryMode_220129 _1280638;
_1280638.e0 = 0;
_1280638.e1 = _1280637;
pbh_lower_1280590 = _1280638;
goto l1280588;
l1280587: ;
union variant_220130 _1265919_3403;
_1265919_3403.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3405;
_1265920_3405.e0 = 1;
_1265920_3405.e1 = _1265919_3403;
pbh_lower_1280590 = _1265920_3405;
goto l1280588;
l1280588: ;
bh_lower_1280590 = pbh_lower_1280590;
union variant_220130 _1280594;
_1280594 = bh_lower_1280590.e1;
unsigned int _1280591;
_1280591 = bh_lower_1280590.e0;
bool _1280592;
_1280592 = _1280591 == 0;
if (_1280592) goto l1280593; else goto l1280631;
l1280631: ;
bool _1280632;
_1280632 = _1280591 == 1;
if (_1280632) goto l1280633; else goto l1280635;
l1280635: ;
// bottom: float r4_1265918_3413;
// bottom: p_1280605 = r4_1265918_3413;
goto l1280603;
l1280633: ;
float c_1280634;
c_1280634 = _1280594.pf32;
p_1280605 = c_1280634;
goto l1280603;
l1280593: ;
int y_1280595;
y_1280595 = _1280594.qs32;
int _1280596;
_1280596 = y_1280595 * _1280513;
int _1280597;
_1280597 = _1280596 + gid_x_1280516;
int _1280598;
_1280598 = 128 + _1280597;
float* idx_1280599;
idx_1280599 = _1034602_1280476 + _1280598;
_1280602 = __ldg(idx_1280599);
p_1280602 = _1280602;
l1280600: ;
_1280602 = p_1280602;
p_1280605 = _1280602;
goto l1280603;
l1280603: ;
_1280605 = p_1280605;
float _1280618;
_1280618 = _1280617;
float _1280619;
_1280619 = 2.000000e-01f * _1280618;
float _1280623;
_1280623 = 2.500000e-01f * _1280565;
float _1280625;
_1280625 = 2.500000e-01f * _1280584;
float _1280621;
_1280621 = 2.500000e-01f * _1280546;
float _1280627;
_1280627 = 2.500000e-01f * _1280605;
float _1280611;
_1280611 = 2.000000e-01f * _1280525;
int _1280606;
_1280606 = _1034604_1280478.e3;
float _1280620;
_1280620 = _1280611 + _1280619;
float _1280622;
_1280622 = 0.000000e+00f + _1280621;
float _1280624;
_1280624 = _1280622 + _1280623;
float _1280626;
_1280626 = _1280624 + _1280625;
float _1280628;
_1280628 = _1280626 + _1280627;
int _1280607;
_1280607 = gid_y_1280502 * _1280606;
float val_1280629;
val_1280629 = _1280620 + _1280628;
int _1280608;
_1280608 = _1280607 + gid_x_1280516;
int _1280609;
_1280609 = 128 + _1280608;
float* idx_1280610;
idx_1280610 = _1034600_1280474 + _1280609;
*idx_1280610 = val_1280629;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1027667(struct_Img_220118 _1027670_1271469, float* _1027671_1271470, struct_Img_220118 _1027672_1271471, float* _1027673_1271472, float* _1027674_1271473, struct_Img_220118 _1027675_1271474) {
int _1271477;
int p_1271477;
int _1271480;
int p_1271480;
int _1271483;
int p_1271483;
int _1271486;
int p_1271486;
int _1271489;
int p_1271489;
int _1271492;
int p_1271492;
int _1271495;
int p_1271495;
struct_BoundaryMode_220129 bh_upper_1271506;
struct_BoundaryMode_220129 pbh_upper_1271506;
struct_BoundaryMode_220129 bh_upper_1271517;
struct_BoundaryMode_220129 pbh_upper_1271517;
float _1271534;
float p_1271534;
float _1271537;
float p_1271537;
struct_BoundaryMode_220129 bh_upper_1271541;
struct_BoundaryMode_220129 pbh_upper_1271541;
struct_BoundaryMode_220129 bh_upper_1271547;
struct_BoundaryMode_220129 pbh_upper_1271547;
float _1271563;
float p_1271563;
float _1271566;
float p_1271566;
struct_BoundaryMode_220129 bh_upper_1271572;
struct_BoundaryMode_220129 pbh_upper_1271572;
struct_BoundaryMode_220129 bh_upper_1271576;
struct_BoundaryMode_220129 pbh_upper_1271576;
float _1271592;
float p_1271592;
float _1271595;
float p_1271595;
struct_BoundaryMode_220129 bh_upper_1271601;
struct_BoundaryMode_220129 pbh_upper_1271601;
struct_BoundaryMode_220129 bh_upper_1271605;
struct_BoundaryMode_220129 pbh_upper_1271605;
float _1271621;
float p_1271621;
float _1271624;
float p_1271624;
struct_BoundaryMode_220129 bh_upper_1271628;
struct_BoundaryMode_220129 pbh_upper_1271628;
struct_BoundaryMode_220129 bh_upper_1271634;
struct_BoundaryMode_220129 pbh_upper_1271634;
float _1271650;
float p_1271650;
float _1271653;
float p_1271653;
_1271477 = threadIdx_x();
p_1271477 = _1271477;
l1271475: ;
_1271477 = p_1271477;
_1271480 = blockDim_x();
p_1271480 = _1271480;
l1271478: ;
_1271480 = p_1271480;
_1271483 = blockIdx_x();
p_1271483 = _1271483;
l1271481: ;
_1271483 = p_1271483;
_1271486 = threadIdx_y();
p_1271486 = _1271486;
l1271484: ;
_1271486 = p_1271486;
_1271489 = blockDim_y();
p_1271489 = _1271489;
l1271487: ;
_1271489 = p_1271489;
_1271492 = blockIdx_y();
p_1271492 = _1271492;
l1271490: ;
_1271492 = p_1271492;
_1271495 = blockDim_y();
p_1271495 = _1271495;
l1271493: ;
_1271495 = p_1271495;
int _1271497;
_1271497 = _1027672_1271471.e1;
int _1271500;
_1271500 = _1271480 * _1271483;
int _1271496;
_1271496 = _1027670_1271469.e1;
int _1271498;
_1271498 = _1271497 - 128;
int _1271499;
_1271499 = _1271498 + _1271477;
int gid_x_1271501;
gid_x_1271501 = _1271499 + _1271500;
bool _1271502;
_1271502 = _1271496 <= gid_x_1271501;
union variant_220130 _1271690;
_1271690.qs32 = gid_x_1271501;
struct_BoundaryMode_220129 _1271691;
_1271691.e0 = 0;
_1271691.e1 = _1271690;
if (_1271502) goto l1271503; else goto l1271744;
l1271744: ;
pbh_upper_1271506 = _1271691;
goto l1271504;
l1271503: ;
union variant_220130 _1265919_3430;
_1265919_3430.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3432;
_1265920_3432.e0 = 1;
_1265920_3432.e1 = _1265919_3430;
pbh_upper_1271506 = _1265920_3432;
goto l1271504;
l1271504: ;
bh_upper_1271506 = pbh_upper_1271506;
int _1271507;
_1271507 = _1027670_1271469.e2;
int _1271511;
_1271511 = _1271489 * _1271492;
int _1271508;
_1271508 = _1027672_1271471.e2;
int _1271509;
_1271509 = _1271508 - 1;
int _1271510;
_1271510 = _1271509 + _1271486;
int gid_y_1271512;
gid_y_1271512 = _1271510 + _1271511;
union variant_220130 _1271702;
_1271702.qs32 = gid_y_1271512;
bool _1271513;
_1271513 = _1271507 <= gid_y_1271512;
struct_BoundaryMode_220129 _1271703;
_1271703.e0 = 0;
_1271703.e1 = _1271702;
if (_1271513) goto l1271514; else goto l1271743;
l1271743: ;
pbh_upper_1271517 = _1271703;
goto l1271515;
l1271514: ;
union variant_220130 _1265919_3442;
_1265919_3442.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3444;
_1265920_3444.e0 = 1;
_1265920_3444.e1 = _1265919_3442;
pbh_upper_1271517 = _1265920_3444;
goto l1271515;
l1271515: ;
bh_upper_1271517 = pbh_upper_1271517;
unsigned int _1271518;
_1271518 = bh_upper_1271506.e0;
int _1271526;
_1271526 = _1027670_1271469.e3;
union variant_220130 _1271524;
_1271524 = bh_upper_1271517.e1;
union variant_220130 _1271528;
_1271528 = bh_upper_1271506.e1;
unsigned int _1271520;
_1271520 = bh_upper_1271517.e0;
bool _1271521;
_1271521 = _1271520 == 0;
bool _1271519;
_1271519 = _1271518 == 0;
bool _1271522;
_1271522 = _1271519 & _1271521;
if (_1271522) goto l1271523; else goto l1271734;
l1271734: ;
bool _1271735;
_1271735 = _1271518 == 1;
if (_1271735) goto l1271736; else goto l1271738;
l1271738: ;
bool _1271739;
_1271739 = _1271520 == 1;
if (_1271739) goto l1271740; else goto l1271742;
l1271742: ;
// bottom: float r4_1265918_3457;
// bottom: p_1271537 = r4_1265918_3457;
goto l1271535;
l1271740: ;
float c_1271741;
c_1271741 = _1271524.pf32;
p_1271537 = c_1271741;
goto l1271535;
l1271736: ;
float c_1271737;
c_1271737 = _1271528.pf32;
p_1271537 = c_1271737;
goto l1271535;
l1271523: ;
int x_1271529;
x_1271529 = _1271528.qs32;
int y_1271525;
y_1271525 = _1271524.qs32;
int _1271527;
_1271527 = y_1271525 * _1271526;
int _1271530;
_1271530 = _1271527 + x_1271529;
float* idx_1271531;
idx_1271531 = _1027673_1271472 + _1271530;
_1271534 = __ldg(idx_1271531);
p_1271534 = _1271534;
l1271532: ;
_1271534 = p_1271534;
p_1271537 = _1271534;
goto l1271535;
l1271535: ;
_1271537 = p_1271537;
int _1271659;
_1271659 = _1027675_1271474.e3;
int _1271660;
_1271660 = gid_y_1271512 * _1271659;
int _1271661;
_1271661 = _1271660 + gid_x_1271501;
float* idx_1271662;
idx_1271662 = _1027671_1271470 + _1271661;
float _1271663;
_1271663 = *idx_1271662;
if (_1271502) goto l1271538; else goto l1271733;
l1271733: ;
pbh_upper_1271541 = _1271691;
goto l1271539;
l1271538: ;
union variant_220130 _1265919_3459;
_1265919_3459.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3461;
_1265920_3461.e0 = 1;
_1265920_3461.e1 = _1265919_3459;
pbh_upper_1271541 = _1265920_3461;
goto l1271539;
l1271539: ;
bh_upper_1271541 = pbh_upper_1271541;
int _1271542;
_1271542 = -1 + gid_y_1271512;
bool _1271543;
_1271543 = _1271507 <= _1271542;
if (_1271543) goto l1271544; else goto l1271729;
l1271729: ;
union variant_220130 _1271730;
_1271730.qs32 = _1271542;
struct_BoundaryMode_220129 _1271731;
_1271731.e0 = 0;
_1271731.e1 = _1271730;
pbh_upper_1271547 = _1271731;
goto l1271545;
l1271544: ;
union variant_220130 _1265919_3469;
_1265919_3469.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3471;
_1265920_3471.e0 = 1;
_1265920_3471.e1 = _1265919_3469;
pbh_upper_1271547 = _1265920_3471;
goto l1271545;
l1271545: ;
bh_upper_1271547 = pbh_upper_1271547;
unsigned int _1271550;
_1271550 = bh_upper_1271547.e0;
unsigned int _1271548;
_1271548 = bh_upper_1271541.e0;
union variant_220130 _1271557;
_1271557 = bh_upper_1271541.e1;
union variant_220130 _1271554;
_1271554 = bh_upper_1271547.e1;
bool _1271551;
_1271551 = _1271550 == 0;
bool _1271549;
_1271549 = _1271548 == 0;
bool _1271552;
_1271552 = _1271549 & _1271551;
if (_1271552) goto l1271553; else goto l1271720;
l1271720: ;
bool _1271721;
_1271721 = _1271548 == 1;
if (_1271721) goto l1271722; else goto l1271724;
l1271724: ;
bool _1271725;
_1271725 = _1271550 == 1;
if (_1271725) goto l1271726; else goto l1271728;
l1271728: ;
// bottom: float r4_1265918_3483;
// bottom: p_1271566 = r4_1265918_3483;
goto l1271564;
l1271726: ;
float c_1271727;
c_1271727 = _1271554.pf32;
p_1271566 = c_1271727;
goto l1271564;
l1271722: ;
float c_1271723;
c_1271723 = _1271557.pf32;
p_1271566 = c_1271723;
goto l1271564;
l1271553: ;
int x_1271558;
x_1271558 = _1271557.qs32;
int y_1271555;
y_1271555 = _1271554.qs32;
int _1271556;
_1271556 = y_1271555 * _1271526;
int _1271559;
_1271559 = _1271556 + x_1271558;
float* idx_1271560;
idx_1271560 = _1027673_1271472 + _1271559;
_1271563 = __ldg(idx_1271560);
p_1271563 = _1271563;
l1271561: ;
_1271563 = p_1271563;
p_1271566 = _1271563;
goto l1271564;
l1271564: ;
_1271566 = p_1271566;
int _1271567;
_1271567 = -1 + gid_x_1271501;
bool _1271568;
_1271568 = _1271496 <= _1271567;
if (_1271568) goto l1271569; else goto l1271717;
l1271717: ;
union variant_220130 _1271718;
_1271718.qs32 = _1271567;
struct_BoundaryMode_220129 _1271719;
_1271719.e0 = 0;
_1271719.e1 = _1271718;
pbh_upper_1271572 = _1271719;
goto l1271570;
l1271569: ;
union variant_220130 _1265919_3488;
_1265919_3488.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3490;
_1265920_3490.e0 = 1;
_1265920_3490.e1 = _1265919_3488;
pbh_upper_1271572 = _1265920_3490;
goto l1271570;
l1271570: ;
bh_upper_1271572 = pbh_upper_1271572;
if (_1271513) goto l1271573; else goto l1271716;
l1271716: ;
pbh_upper_1271576 = _1271703;
goto l1271574;
l1271573: ;
union variant_220130 _1265919_3494;
_1265919_3494.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3496;
_1265920_3496.e0 = 1;
_1265920_3496.e1 = _1265919_3494;
pbh_upper_1271576 = _1265920_3496;
goto l1271574;
l1271574: ;
bh_upper_1271576 = pbh_upper_1271576;
union variant_220130 _1271583;
_1271583 = bh_upper_1271576.e1;
unsigned int _1271577;
_1271577 = bh_upper_1271572.e0;
union variant_220130 _1271586;
_1271586 = bh_upper_1271572.e1;
unsigned int _1271579;
_1271579 = bh_upper_1271576.e0;
bool _1271578;
_1271578 = _1271577 == 0;
bool _1271580;
_1271580 = _1271579 == 0;
bool _1271581;
_1271581 = _1271578 & _1271580;
if (_1271581) goto l1271582; else goto l1271707;
l1271707: ;
bool _1271708;
_1271708 = _1271577 == 1;
if (_1271708) goto l1271709; else goto l1271711;
l1271711: ;
bool _1271712;
_1271712 = _1271579 == 1;
if (_1271712) goto l1271713; else goto l1271715;
l1271715: ;
// bottom: float r4_1265918_3508;
// bottom: p_1271595 = r4_1265918_3508;
goto l1271593;
l1271713: ;
float c_1271714;
c_1271714 = _1271583.pf32;
p_1271595 = c_1271714;
goto l1271593;
l1271709: ;
float c_1271710;
c_1271710 = _1271586.pf32;
p_1271595 = c_1271710;
goto l1271593;
l1271582: ;
int y_1271584;
y_1271584 = _1271583.qs32;
int x_1271587;
x_1271587 = _1271586.qs32;
int _1271585;
_1271585 = y_1271584 * _1271526;
int _1271588;
_1271588 = _1271585 + x_1271587;
float* idx_1271589;
idx_1271589 = _1027673_1271472 + _1271588;
_1271592 = __ldg(idx_1271589);
p_1271592 = _1271592;
l1271590: ;
_1271592 = p_1271592;
p_1271595 = _1271592;
goto l1271593;
l1271593: ;
_1271595 = p_1271595;
int _1271596;
_1271596 = 1 + gid_x_1271501;
bool _1271597;
_1271597 = _1271496 <= _1271596;
if (_1271597) goto l1271598; else goto l1271704;
l1271704: ;
union variant_220130 _1271705;
_1271705.qs32 = _1271596;
struct_BoundaryMode_220129 _1271706;
_1271706.e0 = 0;
_1271706.e1 = _1271705;
pbh_upper_1271601 = _1271706;
goto l1271599;
l1271598: ;
union variant_220130 _1265919_3513;
_1265919_3513.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3515;
_1265920_3515.e0 = 1;
_1265920_3515.e1 = _1265919_3513;
pbh_upper_1271601 = _1265920_3515;
goto l1271599;
l1271599: ;
bh_upper_1271601 = pbh_upper_1271601;
if (_1271513) goto l1271602; else goto l1271701;
l1271701: ;
pbh_upper_1271605 = _1271703;
goto l1271603;
l1271602: ;
union variant_220130 _1265919_3519;
_1265919_3519.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3521;
_1265920_3521.e0 = 1;
_1265920_3521.e1 = _1265919_3519;
pbh_upper_1271605 = _1265920_3521;
goto l1271603;
l1271603: ;
bh_upper_1271605 = pbh_upper_1271605;
unsigned int _1271608;
_1271608 = bh_upper_1271605.e0;
unsigned int _1271606;
_1271606 = bh_upper_1271601.e0;
bool _1271607;
_1271607 = _1271606 == 0;
union variant_220130 _1271612;
_1271612 = bh_upper_1271605.e1;
union variant_220130 _1271615;
_1271615 = bh_upper_1271601.e1;
bool _1271609;
_1271609 = _1271608 == 0;
bool _1271610;
_1271610 = _1271607 & _1271609;
if (_1271610) goto l1271611; else goto l1271692;
l1271692: ;
bool _1271693;
_1271693 = _1271606 == 1;
if (_1271693) goto l1271694; else goto l1271696;
l1271696: ;
bool _1271697;
_1271697 = _1271608 == 1;
if (_1271697) goto l1271698; else goto l1271700;
l1271700: ;
// bottom: float r4_1265918_3533;
// bottom: p_1271624 = r4_1265918_3533;
goto l1271622;
l1271698: ;
float c_1271699;
c_1271699 = _1271612.pf32;
p_1271624 = c_1271699;
goto l1271622;
l1271694: ;
float c_1271695;
c_1271695 = _1271615.pf32;
p_1271624 = c_1271695;
goto l1271622;
l1271611: ;
int x_1271616;
x_1271616 = _1271615.qs32;
int y_1271613;
y_1271613 = _1271612.qs32;
int _1271614;
_1271614 = y_1271613 * _1271526;
int _1271617;
_1271617 = _1271614 + x_1271616;
float* idx_1271618;
idx_1271618 = _1027673_1271472 + _1271617;
_1271621 = __ldg(idx_1271618);
p_1271621 = _1271621;
l1271619: ;
_1271621 = p_1271621;
p_1271624 = _1271621;
goto l1271622;
l1271622: ;
_1271624 = p_1271624;
if (_1271502) goto l1271625; else goto l1271689;
l1271689: ;
pbh_upper_1271628 = _1271691;
goto l1271626;
l1271625: ;
union variant_220130 _1265919_3534;
_1265919_3534.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3536;
_1265920_3536.e0 = 1;
_1265920_3536.e1 = _1265919_3534;
pbh_upper_1271628 = _1265920_3536;
goto l1271626;
l1271626: ;
bh_upper_1271628 = pbh_upper_1271628;
int _1271629;
_1271629 = 1 + gid_y_1271512;
bool _1271630;
_1271630 = _1271507 <= _1271629;
if (_1271630) goto l1271631; else goto l1271686;
l1271686: ;
union variant_220130 _1271687;
_1271687.qs32 = _1271629;
struct_BoundaryMode_220129 _1271688;
_1271688.e0 = 0;
_1271688.e1 = _1271687;
pbh_upper_1271634 = _1271688;
goto l1271632;
l1271631: ;
union variant_220130 _1265919_3544;
_1265919_3544.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3546;
_1265920_3546.e0 = 1;
_1265920_3546.e1 = _1265919_3544;
pbh_upper_1271634 = _1265920_3546;
goto l1271632;
l1271632: ;
bh_upper_1271634 = pbh_upper_1271634;
union variant_220130 _1271644;
_1271644 = bh_upper_1271628.e1;
unsigned int _1271635;
_1271635 = bh_upper_1271628.e0;
union variant_220130 _1271641;
_1271641 = bh_upper_1271634.e1;
bool _1271636;
_1271636 = _1271635 == 0;
unsigned int _1271637;
_1271637 = bh_upper_1271634.e0;
bool _1271638;
_1271638 = _1271637 == 0;
bool _1271639;
_1271639 = _1271636 & _1271638;
if (_1271639) goto l1271640; else goto l1271677;
l1271677: ;
bool _1271678;
_1271678 = _1271635 == 1;
if (_1271678) goto l1271679; else goto l1271681;
l1271681: ;
bool _1271682;
_1271682 = _1271637 == 1;
if (_1271682) goto l1271683; else goto l1271685;
l1271685: ;
// bottom: float r4_1265918_3558;
// bottom: p_1271653 = r4_1265918_3558;
goto l1271651;
l1271683: ;
float c_1271684;
c_1271684 = _1271641.pf32;
p_1271653 = c_1271684;
goto l1271651;
l1271679: ;
float c_1271680;
c_1271680 = _1271644.pf32;
p_1271653 = c_1271680;
goto l1271651;
l1271640: ;
int y_1271642;
y_1271642 = _1271641.qs32;
int _1271643;
_1271643 = y_1271642 * _1271526;
int x_1271645;
x_1271645 = _1271644.qs32;
int _1271646;
_1271646 = _1271643 + x_1271645;
float* idx_1271647;
idx_1271647 = _1027673_1271472 + _1271646;
_1271650 = __ldg(idx_1271647);
p_1271650 = _1271650;
l1271648: ;
_1271650 = p_1271650;
p_1271653 = _1271650;
goto l1271651;
l1271651: ;
_1271653 = p_1271653;
float _1271669;
_1271669 = 2.500000e-01f * _1271595;
float _1271673;
_1271673 = 2.500000e-01f * _1271653;
float _1271664;
_1271664 = _1271663;
float _1271658;
_1271658 = 2.000000e-01f * _1271537;
int _1271654;
_1271654 = _1027672_1271471.e3;
int _1271655;
_1271655 = gid_y_1271512 * _1271654;
float _1271667;
_1271667 = 2.500000e-01f * _1271566;
float _1271671;
_1271671 = 2.500000e-01f * _1271624;
float _1271665;
_1271665 = 2.000000e-01f * _1271664;
float _1271666;
_1271666 = _1271658 + _1271665;
int _1271656;
_1271656 = _1271655 + gid_x_1271501;
float _1271668;
_1271668 = 0.000000e+00f + _1271667;
float* idx_1271657;
idx_1271657 = _1027674_1271473 + _1271656;
float _1271670;
_1271670 = _1271668 + _1271669;
float _1271672;
_1271672 = _1271670 + _1271671;
float _1271674;
_1271674 = _1271672 + _1271673;
float val_1271675;
val_1271675 = _1271666 + _1271674;
*idx_1271657 = val_1271675;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1019376(float* _1019379_1277057, struct_Img_220118 _1019380_1277058, float* _1019381_1277059, float* _1019382_1277060, struct_Img_220118 _1019383_1277061, struct_Img_220118 _1019384_1277062) {
int _1277065;
int p_1277065;
int _1277068;
int p_1277068;
int _1277071;
int p_1277071;
int _1277074;
int p_1277074;
int _1277077;
int p_1277077;
int _1277080;
int p_1277080;
int _1277083;
int p_1277083;
struct_BoundaryMode_220129 bh_lower_1277090;
struct_BoundaryMode_220129 pbh_lower_1277090;
struct_BoundaryMode_220129 bh_lower_1277097;
struct_BoundaryMode_220129 pbh_lower_1277097;
float _1277114;
float p_1277114;
float _1277117;
float p_1277117;
struct_BoundaryMode_220129 bh_lower_1277121;
struct_BoundaryMode_220129 pbh_lower_1277121;
struct_BoundaryMode_220129 bh_lower_1277127;
struct_BoundaryMode_220129 pbh_lower_1277127;
float _1277143;
float p_1277143;
float _1277146;
float p_1277146;
struct_BoundaryMode_220129 bh_lower_1277152;
struct_BoundaryMode_220129 pbh_lower_1277152;
struct_BoundaryMode_220129 bh_lower_1277156;
struct_BoundaryMode_220129 pbh_lower_1277156;
float _1277172;
float p_1277172;
float _1277175;
float p_1277175;
struct_BoundaryMode_220129 bh_lower_1277181;
struct_BoundaryMode_220129 pbh_lower_1277181;
struct_BoundaryMode_220129 bh_lower_1277185;
struct_BoundaryMode_220129 pbh_lower_1277185;
float _1277201;
float p_1277201;
float _1277204;
float p_1277204;
struct_BoundaryMode_220129 bh_lower_1277208;
struct_BoundaryMode_220129 pbh_lower_1277208;
struct_BoundaryMode_220129 bh_lower_1277214;
struct_BoundaryMode_220129 pbh_lower_1277214;
float _1277230;
float p_1277230;
float _1277233;
float p_1277233;
_1277065 = threadIdx_x();
p_1277065 = _1277065;
l1277063: ;
_1277065 = p_1277065;
_1277068 = blockDim_x();
p_1277068 = _1277068;
l1277066: ;
_1277068 = p_1277068;
_1277071 = blockIdx_x();
p_1277071 = _1277071;
l1277069: ;
_1277071 = p_1277071;
_1277074 = threadIdx_y();
p_1277074 = _1277074;
l1277072: ;
_1277074 = p_1277074;
_1277077 = blockDim_y();
p_1277077 = _1277077;
l1277075: ;
_1277077 = p_1277077;
_1277080 = blockIdx_y();
p_1277080 = _1277080;
l1277078: ;
_1277080 = p_1277080;
_1277083 = blockDim_y();
p_1277083 = _1277083;
l1277081: ;
_1277083 = p_1277083;
int _1277084;
_1277084 = _1277068 * _1277071;
int gid_x_1277085;
gid_x_1277085 = _1277065 + _1277084;
union variant_220130 _1277270;
_1277270.qs32 = gid_x_1277085;
bool _1277086;
_1277086 = gid_x_1277085 < 0;
struct_BoundaryMode_220129 _1277271;
_1277271.e0 = 0;
_1277271.e1 = _1277270;
if (_1277086) goto l1277087; else goto l1277324;
l1277324: ;
pbh_lower_1277090 = _1277271;
goto l1277088;
l1277087: ;
union variant_220130 _1265919_3571;
_1265919_3571.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3573;
_1265920_3573.e0 = 1;
_1265920_3573.e1 = _1265919_3571;
pbh_lower_1277090 = _1265920_3573;
goto l1277088;
l1277088: ;
bh_lower_1277090 = pbh_lower_1277090;
int _1277091;
_1277091 = _1277077 * _1277080;
int gid_y_1277092;
gid_y_1277092 = _1277074 + _1277091;
union variant_220130 _1277282;
_1277282.qs32 = gid_y_1277092;
bool _1277093;
_1277093 = gid_y_1277092 < 0;
struct_BoundaryMode_220129 _1277283;
_1277283.e0 = 0;
_1277283.e1 = _1277282;
if (_1277093) goto l1277094; else goto l1277323;
l1277323: ;
pbh_lower_1277097 = _1277283;
goto l1277095;
l1277094: ;
union variant_220130 _1265919_3581;
_1265919_3581.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3583;
_1265920_3583.e0 = 1;
_1265920_3583.e1 = _1265919_3581;
pbh_lower_1277097 = _1265920_3583;
goto l1277095;
l1277095: ;
bh_lower_1277097 = pbh_lower_1277097;
union variant_220130 _1277104;
_1277104 = bh_lower_1277097.e1;
unsigned int _1277098;
_1277098 = bh_lower_1277090.e0;
union variant_220130 _1277108;
_1277108 = bh_lower_1277090.e1;
unsigned int _1277100;
_1277100 = bh_lower_1277097.e0;
int _1277106;
_1277106 = _1019383_1277061.e3;
bool _1277099;
_1277099 = _1277098 == 0;
bool _1277101;
_1277101 = _1277100 == 0;
bool _1277102;
_1277102 = _1277099 & _1277101;
if (_1277102) goto l1277103; else goto l1277314;
l1277314: ;
bool _1277315;
_1277315 = _1277098 == 1;
if (_1277315) goto l1277316; else goto l1277318;
l1277318: ;
bool _1277319;
_1277319 = _1277100 == 1;
if (_1277319) goto l1277320; else goto l1277322;
l1277322: ;
// bottom: float r4_1265918_3596;
// bottom: p_1277117 = r4_1265918_3596;
goto l1277115;
l1277320: ;
float c_1277321;
c_1277321 = _1277104.pf32;
p_1277117 = c_1277321;
goto l1277115;
l1277316: ;
float c_1277317;
c_1277317 = _1277108.pf32;
p_1277117 = c_1277317;
goto l1277115;
l1277103: ;
int x_1277109;
x_1277109 = _1277108.qs32;
int y_1277105;
y_1277105 = _1277104.qs32;
int _1277107;
_1277107 = y_1277105 * _1277106;
int _1277110;
_1277110 = _1277107 + x_1277109;
float* idx_1277111;
idx_1277111 = _1019382_1277060 + _1277110;
_1277114 = __ldg(idx_1277111);
p_1277114 = _1277114;
l1277112: ;
_1277114 = p_1277114;
p_1277117 = _1277114;
goto l1277115;
l1277115: ;
_1277117 = p_1277117;
int _1277239;
_1277239 = _1019384_1277062.e3;
int _1277240;
_1277240 = gid_y_1277092 * _1277239;
int _1277241;
_1277241 = _1277240 + gid_x_1277085;
float* idx_1277242;
idx_1277242 = _1019379_1277057 + _1277241;
float _1277243;
_1277243 = *idx_1277242;
if (_1277086) goto l1277118; else goto l1277313;
l1277313: ;
pbh_lower_1277121 = _1277271;
goto l1277119;
l1277118: ;
union variant_220130 _1265919_3598;
_1265919_3598.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3600;
_1265920_3600.e0 = 1;
_1265920_3600.e1 = _1265919_3598;
pbh_lower_1277121 = _1265920_3600;
goto l1277119;
l1277119: ;
bh_lower_1277121 = pbh_lower_1277121;
int _1277122;
_1277122 = -1 + gid_y_1277092;
bool _1277123;
_1277123 = _1277122 < 0;
if (_1277123) goto l1277124; else goto l1277309;
l1277309: ;
union variant_220130 _1277310;
_1277310.qs32 = _1277122;
struct_BoundaryMode_220129 _1277311;
_1277311.e0 = 0;
_1277311.e1 = _1277310;
pbh_lower_1277127 = _1277311;
goto l1277125;
l1277124: ;
union variant_220130 _1265919_3609;
_1265919_3609.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3611;
_1265920_3611.e0 = 1;
_1265920_3611.e1 = _1265919_3609;
pbh_lower_1277127 = _1265920_3611;
goto l1277125;
l1277125: ;
bh_lower_1277127 = pbh_lower_1277127;
union variant_220130 _1277137;
_1277137 = bh_lower_1277121.e1;
unsigned int _1277128;
_1277128 = bh_lower_1277121.e0;
union variant_220130 _1277134;
_1277134 = bh_lower_1277127.e1;
unsigned int _1277130;
_1277130 = bh_lower_1277127.e0;
bool _1277129;
_1277129 = _1277128 == 0;
bool _1277131;
_1277131 = _1277130 == 0;
bool _1277132;
_1277132 = _1277129 & _1277131;
if (_1277132) goto l1277133; else goto l1277300;
l1277300: ;
bool _1277301;
_1277301 = _1277128 == 1;
if (_1277301) goto l1277302; else goto l1277304;
l1277304: ;
bool _1277305;
_1277305 = _1277130 == 1;
if (_1277305) goto l1277306; else goto l1277308;
l1277308: ;
// bottom: float r4_1265918_3623;
// bottom: p_1277146 = r4_1265918_3623;
goto l1277144;
l1277306: ;
float c_1277307;
c_1277307 = _1277134.pf32;
p_1277146 = c_1277307;
goto l1277144;
l1277302: ;
float c_1277303;
c_1277303 = _1277137.pf32;
p_1277146 = c_1277303;
goto l1277144;
l1277133: ;
int y_1277135;
y_1277135 = _1277134.qs32;
int x_1277138;
x_1277138 = _1277137.qs32;
int _1277136;
_1277136 = y_1277135 * _1277106;
int _1277139;
_1277139 = _1277136 + x_1277138;
float* idx_1277140;
idx_1277140 = _1019382_1277060 + _1277139;
_1277143 = __ldg(idx_1277140);
p_1277143 = _1277143;
l1277141: ;
_1277143 = p_1277143;
p_1277146 = _1277143;
goto l1277144;
l1277144: ;
_1277146 = p_1277146;
int _1277147;
_1277147 = -1 + gid_x_1277085;
bool _1277148;
_1277148 = _1277147 < 0;
if (_1277148) goto l1277149; else goto l1277297;
l1277297: ;
union variant_220130 _1277298;
_1277298.qs32 = _1277147;
struct_BoundaryMode_220129 _1277299;
_1277299.e0 = 0;
_1277299.e1 = _1277298;
pbh_lower_1277152 = _1277299;
goto l1277150;
l1277149: ;
union variant_220130 _1265919_3629;
_1265919_3629.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3631;
_1265920_3631.e0 = 1;
_1265920_3631.e1 = _1265919_3629;
pbh_lower_1277152 = _1265920_3631;
goto l1277150;
l1277150: ;
bh_lower_1277152 = pbh_lower_1277152;
if (_1277093) goto l1277153; else goto l1277296;
l1277296: ;
pbh_lower_1277156 = _1277283;
goto l1277154;
l1277153: ;
union variant_220130 _1265919_3635;
_1265919_3635.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3637;
_1265920_3637.e0 = 1;
_1265920_3637.e1 = _1265919_3635;
pbh_lower_1277156 = _1265920_3637;
goto l1277154;
l1277154: ;
bh_lower_1277156 = pbh_lower_1277156;
union variant_220130 _1277166;
_1277166 = bh_lower_1277152.e1;
unsigned int _1277157;
_1277157 = bh_lower_1277152.e0;
unsigned int _1277159;
_1277159 = bh_lower_1277156.e0;
union variant_220130 _1277163;
_1277163 = bh_lower_1277156.e1;
bool _1277158;
_1277158 = _1277157 == 0;
bool _1277160;
_1277160 = _1277159 == 0;
bool _1277161;
_1277161 = _1277158 & _1277160;
if (_1277161) goto l1277162; else goto l1277287;
l1277287: ;
bool _1277288;
_1277288 = _1277157 == 1;
if (_1277288) goto l1277289; else goto l1277291;
l1277291: ;
bool _1277292;
_1277292 = _1277159 == 1;
if (_1277292) goto l1277293; else goto l1277295;
l1277295: ;
// bottom: float r4_1265918_3649;
// bottom: p_1277175 = r4_1265918_3649;
goto l1277173;
l1277293: ;
float c_1277294;
c_1277294 = _1277163.pf32;
p_1277175 = c_1277294;
goto l1277173;
l1277289: ;
float c_1277290;
c_1277290 = _1277166.pf32;
p_1277175 = c_1277290;
goto l1277173;
l1277162: ;
int y_1277164;
y_1277164 = _1277163.qs32;
int x_1277167;
x_1277167 = _1277166.qs32;
int _1277165;
_1277165 = y_1277164 * _1277106;
int _1277168;
_1277168 = _1277165 + x_1277167;
float* idx_1277169;
idx_1277169 = _1019382_1277060 + _1277168;
_1277172 = __ldg(idx_1277169);
p_1277172 = _1277172;
l1277170: ;
_1277172 = p_1277172;
p_1277175 = _1277172;
goto l1277173;
l1277173: ;
_1277175 = p_1277175;
int _1277176;
_1277176 = 1 + gid_x_1277085;
bool _1277177;
_1277177 = _1277176 < 0;
if (_1277177) goto l1277178; else goto l1277284;
l1277284: ;
union variant_220130 _1277285;
_1277285.qs32 = _1277176;
struct_BoundaryMode_220129 _1277286;
_1277286.e0 = 0;
_1277286.e1 = _1277285;
pbh_lower_1277181 = _1277286;
goto l1277179;
l1277178: ;
union variant_220130 _1265919_3655;
_1265919_3655.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3657;
_1265920_3657.e0 = 1;
_1265920_3657.e1 = _1265919_3655;
pbh_lower_1277181 = _1265920_3657;
goto l1277179;
l1277179: ;
bh_lower_1277181 = pbh_lower_1277181;
if (_1277093) goto l1277182; else goto l1277281;
l1277281: ;
pbh_lower_1277185 = _1277283;
goto l1277183;
l1277182: ;
union variant_220130 _1265919_3661;
_1265919_3661.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3663;
_1265920_3663.e0 = 1;
_1265920_3663.e1 = _1265919_3661;
pbh_lower_1277185 = _1265920_3663;
goto l1277183;
l1277183: ;
bh_lower_1277185 = pbh_lower_1277185;
union variant_220130 _1277192;
_1277192 = bh_lower_1277185.e1;
unsigned int _1277186;
_1277186 = bh_lower_1277181.e0;
union variant_220130 _1277195;
_1277195 = bh_lower_1277181.e1;
unsigned int _1277188;
_1277188 = bh_lower_1277185.e0;
bool _1277187;
_1277187 = _1277186 == 0;
bool _1277189;
_1277189 = _1277188 == 0;
bool _1277190;
_1277190 = _1277187 & _1277189;
if (_1277190) goto l1277191; else goto l1277272;
l1277272: ;
bool _1277273;
_1277273 = _1277186 == 1;
if (_1277273) goto l1277274; else goto l1277276;
l1277276: ;
bool _1277277;
_1277277 = _1277188 == 1;
if (_1277277) goto l1277278; else goto l1277280;
l1277280: ;
// bottom: float r4_1265918_3675;
// bottom: p_1277204 = r4_1265918_3675;
goto l1277202;
l1277278: ;
float c_1277279;
c_1277279 = _1277192.pf32;
p_1277204 = c_1277279;
goto l1277202;
l1277274: ;
float c_1277275;
c_1277275 = _1277195.pf32;
p_1277204 = c_1277275;
goto l1277202;
l1277191: ;
int y_1277193;
y_1277193 = _1277192.qs32;
int _1277194;
_1277194 = y_1277193 * _1277106;
int x_1277196;
x_1277196 = _1277195.qs32;
int _1277197;
_1277197 = _1277194 + x_1277196;
float* idx_1277198;
idx_1277198 = _1019382_1277060 + _1277197;
_1277201 = __ldg(idx_1277198);
p_1277201 = _1277201;
l1277199: ;
_1277201 = p_1277201;
p_1277204 = _1277201;
goto l1277202;
l1277202: ;
_1277204 = p_1277204;
if (_1277086) goto l1277205; else goto l1277269;
l1277269: ;
pbh_lower_1277208 = _1277271;
goto l1277206;
l1277205: ;
union variant_220130 _1265919_3676;
_1265919_3676.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3678;
_1265920_3678.e0 = 1;
_1265920_3678.e1 = _1265919_3676;
pbh_lower_1277208 = _1265920_3678;
goto l1277206;
l1277206: ;
bh_lower_1277208 = pbh_lower_1277208;
int _1277209;
_1277209 = 1 + gid_y_1277092;
bool _1277210;
_1277210 = _1277209 < 0;
if (_1277210) goto l1277211; else goto l1277266;
l1277266: ;
union variant_220130 _1277267;
_1277267.qs32 = _1277209;
struct_BoundaryMode_220129 _1277268;
_1277268.e0 = 0;
_1277268.e1 = _1277267;
pbh_lower_1277214 = _1277268;
goto l1277212;
l1277211: ;
union variant_220130 _1265919_3687;
_1265919_3687.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3689;
_1265920_3689.e0 = 1;
_1265920_3689.e1 = _1265919_3687;
pbh_lower_1277214 = _1265920_3689;
goto l1277212;
l1277212: ;
bh_lower_1277214 = pbh_lower_1277214;
union variant_220130 _1277221;
_1277221 = bh_lower_1277214.e1;
union variant_220130 _1277224;
_1277224 = bh_lower_1277208.e1;
unsigned int _1277217;
_1277217 = bh_lower_1277214.e0;
unsigned int _1277215;
_1277215 = bh_lower_1277208.e0;
bool _1277218;
_1277218 = _1277217 == 0;
bool _1277216;
_1277216 = _1277215 == 0;
bool _1277219;
_1277219 = _1277216 & _1277218;
if (_1277219) goto l1277220; else goto l1277257;
l1277257: ;
bool _1277258;
_1277258 = _1277215 == 1;
if (_1277258) goto l1277259; else goto l1277261;
l1277261: ;
bool _1277262;
_1277262 = _1277217 == 1;
if (_1277262) goto l1277263; else goto l1277265;
l1277265: ;
// bottom: float r4_1265918_3701;
// bottom: p_1277233 = r4_1265918_3701;
goto l1277231;
l1277263: ;
float c_1277264;
c_1277264 = _1277221.pf32;
p_1277233 = c_1277264;
goto l1277231;
l1277259: ;
float c_1277260;
c_1277260 = _1277224.pf32;
p_1277233 = c_1277260;
goto l1277231;
l1277220: ;
int x_1277225;
x_1277225 = _1277224.qs32;
int y_1277222;
y_1277222 = _1277221.qs32;
int _1277223;
_1277223 = y_1277222 * _1277106;
int _1277226;
_1277226 = _1277223 + x_1277225;
float* idx_1277227;
idx_1277227 = _1019382_1277060 + _1277226;
_1277230 = __ldg(idx_1277227);
p_1277230 = _1277230;
l1277228: ;
_1277230 = p_1277230;
p_1277233 = _1277230;
goto l1277231;
l1277231: ;
_1277233 = p_1277233;
float _1277249;
_1277249 = 2.500000e-01f * _1277175;
int _1277234;
_1277234 = _1019380_1277058.e3;
float _1277247;
_1277247 = 2.500000e-01f * _1277146;
float _1277248;
_1277248 = 0.000000e+00f + _1277247;
float _1277238;
_1277238 = 2.000000e-01f * _1277117;
float _1277253;
_1277253 = 2.500000e-01f * _1277233;
float _1277244;
_1277244 = _1277243;
float _1277245;
_1277245 = 2.000000e-01f * _1277244;
float _1277251;
_1277251 = 2.500000e-01f * _1277204;
int _1277235;
_1277235 = gid_y_1277092 * _1277234;
float _1277250;
_1277250 = _1277248 + _1277249;
float _1277246;
_1277246 = _1277238 + _1277245;
float _1277252;
_1277252 = _1277250 + _1277251;
int _1277236;
_1277236 = _1277235 + gid_x_1277085;
float _1277254;
_1277254 = _1277252 + _1277253;
float* idx_1277237;
idx_1277237 = _1019381_1277059 + _1277236;
float val_1277255;
val_1277255 = _1277246 + _1277254;
*idx_1277237 = val_1277255;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1014055(struct_Img_220118 _1014058_1268048, float* _1014059_1268049, struct_Img_220118 _1014060_1268050, float* _1014061_1268051, struct_Img_220118 _1014062_1268052, float* _1014063_1268053) {
int _1268056;
int p_1268056;
int _1268059;
int p_1268059;
int _1268062;
int p_1268062;
int _1268065;
int p_1268065;
int _1268068;
int p_1268068;
int _1268071;
int p_1268071;
int _1268074;
int p_1268074;
struct_BoundaryMode_220129 bh_lower_1268081;
struct_BoundaryMode_220129 pbh_lower_1268081;
struct_BoundaryMode_220129 bh_lower_1268088;
struct_BoundaryMode_220129 pbh_lower_1268088;
float _1268105;
float p_1268105;
float _1268108;
float p_1268108;
struct_BoundaryMode_220129 bh_lower_1268112;
struct_BoundaryMode_220129 pbh_lower_1268112;
struct_BoundaryMode_220129 bh_lower_1268118;
struct_BoundaryMode_220129 pbh_lower_1268118;
float _1268134;
float p_1268134;
float _1268137;
float p_1268137;
struct_BoundaryMode_220129 bh_lower_1268143;
struct_BoundaryMode_220129 pbh_lower_1268143;
struct_BoundaryMode_220129 bh_lower_1268147;
struct_BoundaryMode_220129 pbh_lower_1268147;
float _1268163;
float p_1268163;
float _1268166;
float p_1268166;
struct_BoundaryMode_220129 bh_lower_1268172;
struct_BoundaryMode_220129 pbh_lower_1268172;
struct_BoundaryMode_220129 bh_lower_1268176;
struct_BoundaryMode_220129 pbh_lower_1268176;
float _1268192;
float p_1268192;
float _1268195;
float p_1268195;
struct_BoundaryMode_220129 bh_lower_1268199;
struct_BoundaryMode_220129 pbh_lower_1268199;
struct_BoundaryMode_220129 bh_lower_1268205;
struct_BoundaryMode_220129 pbh_lower_1268205;
float _1268221;
float p_1268221;
float _1268224;
float p_1268224;
_1268056 = threadIdx_x();
p_1268056 = _1268056;
l1268054: ;
_1268056 = p_1268056;
_1268059 = blockDim_x();
p_1268059 = _1268059;
l1268057: ;
_1268059 = p_1268059;
_1268062 = blockIdx_x();
p_1268062 = _1268062;
l1268060: ;
_1268062 = p_1268062;
_1268065 = threadIdx_y();
p_1268065 = _1268065;
l1268063: ;
_1268065 = p_1268065;
_1268068 = blockDim_y();
p_1268068 = _1268068;
l1268066: ;
_1268068 = p_1268068;
_1268071 = blockIdx_y();
p_1268071 = _1268071;
l1268069: ;
_1268071 = p_1268071;
_1268074 = blockDim_y();
p_1268074 = _1268074;
l1268072: ;
_1268074 = p_1268074;
int _1268075;
_1268075 = _1268059 * _1268062;
int gid_x_1268076;
gid_x_1268076 = _1268056 + _1268075;
bool _1268077;
_1268077 = gid_x_1268076 < 0;
union variant_220130 _1268261;
_1268261.qs32 = gid_x_1268076;
struct_BoundaryMode_220129 _1268262;
_1268262.e0 = 0;
_1268262.e1 = _1268261;
if (_1268077) goto l1268078; else goto l1268315;
l1268315: ;
pbh_lower_1268081 = _1268262;
goto l1268079;
l1268078: ;
union variant_220130 _1265919_3714;
_1265919_3714.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3716;
_1265920_3716.e0 = 1;
_1265920_3716.e1 = _1265919_3714;
pbh_lower_1268081 = _1265920_3716;
goto l1268079;
l1268079: ;
bh_lower_1268081 = pbh_lower_1268081;
int _1268082;
_1268082 = _1268068 * _1268071;
int gid_y_1268083;
gid_y_1268083 = _1268065 + _1268082;
bool _1268084;
_1268084 = gid_y_1268083 < 0;
union variant_220130 _1268273;
_1268273.qs32 = gid_y_1268083;
struct_BoundaryMode_220129 _1268274;
_1268274.e0 = 0;
_1268274.e1 = _1268273;
if (_1268084) goto l1268085; else goto l1268314;
l1268314: ;
pbh_lower_1268088 = _1268274;
goto l1268086;
l1268085: ;
union variant_220130 _1265919_3724;
_1265919_3724.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3726;
_1265920_3726.e0 = 1;
_1265920_3726.e1 = _1265919_3724;
pbh_lower_1268088 = _1265920_3726;
goto l1268086;
l1268086: ;
bh_lower_1268088 = pbh_lower_1268088;
int _1268097;
_1268097 = _1014062_1268052.e3;
unsigned int _1268091;
_1268091 = bh_lower_1268088.e0;
union variant_220130 _1268099;
_1268099 = bh_lower_1268081.e1;
unsigned int _1268089;
_1268089 = bh_lower_1268081.e0;
union variant_220130 _1268095;
_1268095 = bh_lower_1268088.e1;
bool _1268090;
_1268090 = _1268089 == 0;
bool _1268092;
_1268092 = _1268091 == 0;
bool _1268093;
_1268093 = _1268090 & _1268092;
if (_1268093) goto l1268094; else goto l1268305;
l1268305: ;
bool _1268306;
_1268306 = _1268089 == 1;
if (_1268306) goto l1268307; else goto l1268309;
l1268309: ;
bool _1268310;
_1268310 = _1268091 == 1;
if (_1268310) goto l1268311; else goto l1268313;
l1268313: ;
// bottom: float r4_1265918_3739;
// bottom: p_1268108 = r4_1265918_3739;
goto l1268106;
l1268311: ;
float c_1268312;
c_1268312 = _1268095.pf32;
p_1268108 = c_1268312;
goto l1268106;
l1268307: ;
float c_1268308;
c_1268308 = _1268099.pf32;
p_1268108 = c_1268308;
goto l1268106;
l1268094: ;
int y_1268096;
y_1268096 = _1268095.qs32;
int x_1268100;
x_1268100 = _1268099.qs32;
int _1268098;
_1268098 = y_1268096 * _1268097;
int _1268101;
_1268101 = _1268098 + x_1268100;
float* idx_1268102;
idx_1268102 = _1014061_1268051 + _1268101;
_1268105 = __ldg(idx_1268102);
p_1268105 = _1268105;
l1268103: ;
_1268105 = p_1268105;
p_1268108 = _1268105;
goto l1268106;
l1268106: ;
_1268108 = p_1268108;
int _1268230;
_1268230 = _1014058_1268048.e3;
int _1268231;
_1268231 = gid_y_1268083 * _1268230;
int _1268232;
_1268232 = _1268231 + gid_x_1268076;
float* idx_1268233;
idx_1268233 = _1014063_1268053 + _1268232;
float _1268234;
_1268234 = *idx_1268233;
if (_1268077) goto l1268109; else goto l1268304;
l1268304: ;
pbh_lower_1268112 = _1268262;
goto l1268110;
l1268109: ;
union variant_220130 _1265919_3741;
_1265919_3741.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3743;
_1265920_3743.e0 = 1;
_1265920_3743.e1 = _1265919_3741;
pbh_lower_1268112 = _1265920_3743;
goto l1268110;
l1268110: ;
bh_lower_1268112 = pbh_lower_1268112;
int _1268113;
_1268113 = -1 + gid_y_1268083;
bool _1268114;
_1268114 = _1268113 < 0;
if (_1268114) goto l1268115; else goto l1268300;
l1268300: ;
union variant_220130 _1268301;
_1268301.qs32 = _1268113;
struct_BoundaryMode_220129 _1268302;
_1268302.e0 = 0;
_1268302.e1 = _1268301;
pbh_lower_1268118 = _1268302;
goto l1268116;
l1268115: ;
union variant_220130 _1265919_3752;
_1265919_3752.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3754;
_1265920_3754.e0 = 1;
_1265920_3754.e1 = _1265919_3752;
pbh_lower_1268118 = _1265920_3754;
goto l1268116;
l1268116: ;
bh_lower_1268118 = pbh_lower_1268118;
unsigned int _1268119;
_1268119 = bh_lower_1268112.e0;
union variant_220130 _1268128;
_1268128 = bh_lower_1268112.e1;
bool _1268120;
_1268120 = _1268119 == 0;
union variant_220130 _1268125;
_1268125 = bh_lower_1268118.e1;
unsigned int _1268121;
_1268121 = bh_lower_1268118.e0;
bool _1268122;
_1268122 = _1268121 == 0;
bool _1268123;
_1268123 = _1268120 & _1268122;
if (_1268123) goto l1268124; else goto l1268291;
l1268291: ;
bool _1268292;
_1268292 = _1268119 == 1;
if (_1268292) goto l1268293; else goto l1268295;
l1268295: ;
bool _1268296;
_1268296 = _1268121 == 1;
if (_1268296) goto l1268297; else goto l1268299;
l1268299: ;
// bottom: float r4_1265918_3766;
// bottom: p_1268137 = r4_1265918_3766;
goto l1268135;
l1268297: ;
float c_1268298;
c_1268298 = _1268125.pf32;
p_1268137 = c_1268298;
goto l1268135;
l1268293: ;
float c_1268294;
c_1268294 = _1268128.pf32;
p_1268137 = c_1268294;
goto l1268135;
l1268124: ;
int y_1268126;
y_1268126 = _1268125.qs32;
int x_1268129;
x_1268129 = _1268128.qs32;
int _1268127;
_1268127 = y_1268126 * _1268097;
int _1268130;
_1268130 = _1268127 + x_1268129;
float* idx_1268131;
idx_1268131 = _1014061_1268051 + _1268130;
_1268134 = __ldg(idx_1268131);
p_1268134 = _1268134;
l1268132: ;
_1268134 = p_1268134;
p_1268137 = _1268134;
goto l1268135;
l1268135: ;
_1268137 = p_1268137;
int _1268138;
_1268138 = -1 + gid_x_1268076;
bool _1268139;
_1268139 = _1268138 < 0;
if (_1268139) goto l1268140; else goto l1268288;
l1268288: ;
union variant_220130 _1268289;
_1268289.qs32 = _1268138;
struct_BoundaryMode_220129 _1268290;
_1268290.e0 = 0;
_1268290.e1 = _1268289;
pbh_lower_1268143 = _1268290;
goto l1268141;
l1268140: ;
union variant_220130 _1265919_3772;
_1265919_3772.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3774;
_1265920_3774.e0 = 1;
_1265920_3774.e1 = _1265919_3772;
pbh_lower_1268143 = _1265920_3774;
goto l1268141;
l1268141: ;
bh_lower_1268143 = pbh_lower_1268143;
if (_1268084) goto l1268144; else goto l1268287;
l1268287: ;
pbh_lower_1268147 = _1268274;
goto l1268145;
l1268144: ;
union variant_220130 _1265919_3778;
_1265919_3778.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3780;
_1265920_3780.e0 = 1;
_1265920_3780.e1 = _1265919_3778;
pbh_lower_1268147 = _1265920_3780;
goto l1268145;
l1268145: ;
bh_lower_1268147 = pbh_lower_1268147;
union variant_220130 _1268157;
_1268157 = bh_lower_1268143.e1;
unsigned int _1268150;
_1268150 = bh_lower_1268147.e0;
unsigned int _1268148;
_1268148 = bh_lower_1268143.e0;
bool _1268149;
_1268149 = _1268148 == 0;
union variant_220130 _1268154;
_1268154 = bh_lower_1268147.e1;
bool _1268151;
_1268151 = _1268150 == 0;
bool _1268152;
_1268152 = _1268149 & _1268151;
if (_1268152) goto l1268153; else goto l1268278;
l1268278: ;
bool _1268279;
_1268279 = _1268148 == 1;
if (_1268279) goto l1268280; else goto l1268282;
l1268282: ;
bool _1268283;
_1268283 = _1268150 == 1;
if (_1268283) goto l1268284; else goto l1268286;
l1268286: ;
// bottom: float r4_1265918_3792;
// bottom: p_1268166 = r4_1265918_3792;
goto l1268164;
l1268284: ;
float c_1268285;
c_1268285 = _1268154.pf32;
p_1268166 = c_1268285;
goto l1268164;
l1268280: ;
float c_1268281;
c_1268281 = _1268157.pf32;
p_1268166 = c_1268281;
goto l1268164;
l1268153: ;
int x_1268158;
x_1268158 = _1268157.qs32;
int y_1268155;
y_1268155 = _1268154.qs32;
int _1268156;
_1268156 = y_1268155 * _1268097;
int _1268159;
_1268159 = _1268156 + x_1268158;
float* idx_1268160;
idx_1268160 = _1014061_1268051 + _1268159;
_1268163 = __ldg(idx_1268160);
p_1268163 = _1268163;
l1268161: ;
_1268163 = p_1268163;
p_1268166 = _1268163;
goto l1268164;
l1268164: ;
_1268166 = p_1268166;
int _1268167;
_1268167 = 1 + gid_x_1268076;
bool _1268168;
_1268168 = _1268167 < 0;
if (_1268168) goto l1268169; else goto l1268275;
l1268275: ;
union variant_220130 _1268276;
_1268276.qs32 = _1268167;
struct_BoundaryMode_220129 _1268277;
_1268277.e0 = 0;
_1268277.e1 = _1268276;
pbh_lower_1268172 = _1268277;
goto l1268170;
l1268169: ;
union variant_220130 _1265919_3798;
_1265919_3798.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3800;
_1265920_3800.e0 = 1;
_1265920_3800.e1 = _1265919_3798;
pbh_lower_1268172 = _1265920_3800;
goto l1268170;
l1268170: ;
bh_lower_1268172 = pbh_lower_1268172;
if (_1268084) goto l1268173; else goto l1268272;
l1268272: ;
pbh_lower_1268176 = _1268274;
goto l1268174;
l1268173: ;
union variant_220130 _1265919_3804;
_1265919_3804.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3806;
_1265920_3806.e0 = 1;
_1265920_3806.e1 = _1265919_3804;
pbh_lower_1268176 = _1265920_3806;
goto l1268174;
l1268174: ;
bh_lower_1268176 = pbh_lower_1268176;
unsigned int _1268177;
_1268177 = bh_lower_1268172.e0;
unsigned int _1268179;
_1268179 = bh_lower_1268176.e0;
union variant_220130 _1268183;
_1268183 = bh_lower_1268176.e1;
union variant_220130 _1268186;
_1268186 = bh_lower_1268172.e1;
bool _1268178;
_1268178 = _1268177 == 0;
bool _1268180;
_1268180 = _1268179 == 0;
bool _1268181;
_1268181 = _1268178 & _1268180;
if (_1268181) goto l1268182; else goto l1268263;
l1268263: ;
bool _1268264;
_1268264 = _1268177 == 1;
if (_1268264) goto l1268265; else goto l1268267;
l1268267: ;
bool _1268268;
_1268268 = _1268179 == 1;
if (_1268268) goto l1268269; else goto l1268271;
l1268271: ;
// bottom: float r4_1265918_3818;
// bottom: p_1268195 = r4_1265918_3818;
goto l1268193;
l1268269: ;
float c_1268270;
c_1268270 = _1268183.pf32;
p_1268195 = c_1268270;
goto l1268193;
l1268265: ;
float c_1268266;
c_1268266 = _1268186.pf32;
p_1268195 = c_1268266;
goto l1268193;
l1268182: ;
int y_1268184;
y_1268184 = _1268183.qs32;
int _1268185;
_1268185 = y_1268184 * _1268097;
int x_1268187;
x_1268187 = _1268186.qs32;
int _1268188;
_1268188 = _1268185 + x_1268187;
float* idx_1268189;
idx_1268189 = _1014061_1268051 + _1268188;
_1268192 = __ldg(idx_1268189);
p_1268192 = _1268192;
l1268190: ;
_1268192 = p_1268192;
p_1268195 = _1268192;
goto l1268193;
l1268193: ;
_1268195 = p_1268195;
if (_1268077) goto l1268196; else goto l1268260;
l1268260: ;
pbh_lower_1268199 = _1268262;
goto l1268197;
l1268196: ;
union variant_220130 _1265919_3819;
_1265919_3819.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3821;
_1265920_3821.e0 = 1;
_1265920_3821.e1 = _1265919_3819;
pbh_lower_1268199 = _1265920_3821;
goto l1268197;
l1268197: ;
bh_lower_1268199 = pbh_lower_1268199;
int _1268200;
_1268200 = 1 + gid_y_1268083;
bool _1268201;
_1268201 = _1268200 < 0;
if (_1268201) goto l1268202; else goto l1268257;
l1268257: ;
union variant_220130 _1268258;
_1268258.qs32 = _1268200;
struct_BoundaryMode_220129 _1268259;
_1268259.e0 = 0;
_1268259.e1 = _1268258;
pbh_lower_1268205 = _1268259;
goto l1268203;
l1268202: ;
union variant_220130 _1265919_3830;
_1265919_3830.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3832;
_1265920_3832.e0 = 1;
_1265920_3832.e1 = _1265919_3830;
pbh_lower_1268205 = _1265920_3832;
goto l1268203;
l1268203: ;
bh_lower_1268205 = pbh_lower_1268205;
union variant_220130 _1268215;
_1268215 = bh_lower_1268199.e1;
union variant_220130 _1268212;
_1268212 = bh_lower_1268205.e1;
unsigned int _1268208;
_1268208 = bh_lower_1268205.e0;
unsigned int _1268206;
_1268206 = bh_lower_1268199.e0;
bool _1268209;
_1268209 = _1268208 == 0;
bool _1268207;
_1268207 = _1268206 == 0;
bool _1268210;
_1268210 = _1268207 & _1268209;
if (_1268210) goto l1268211; else goto l1268248;
l1268248: ;
bool _1268249;
_1268249 = _1268206 == 1;
if (_1268249) goto l1268250; else goto l1268252;
l1268252: ;
bool _1268253;
_1268253 = _1268208 == 1;
if (_1268253) goto l1268254; else goto l1268256;
l1268256: ;
// bottom: float r4_1265918_3844;
// bottom: p_1268224 = r4_1265918_3844;
goto l1268222;
l1268254: ;
float c_1268255;
c_1268255 = _1268212.pf32;
p_1268224 = c_1268255;
goto l1268222;
l1268250: ;
float c_1268251;
c_1268251 = _1268215.pf32;
p_1268224 = c_1268251;
goto l1268222;
l1268211: ;
int y_1268213;
y_1268213 = _1268212.qs32;
int _1268214;
_1268214 = y_1268213 * _1268097;
int x_1268216;
x_1268216 = _1268215.qs32;
int _1268217;
_1268217 = _1268214 + x_1268216;
float* idx_1268218;
idx_1268218 = _1014061_1268051 + _1268217;
_1268221 = __ldg(idx_1268218);
p_1268221 = _1268221;
l1268219: ;
_1268221 = p_1268221;
p_1268224 = _1268221;
goto l1268222;
l1268222: ;
_1268224 = p_1268224;
float _1268244;
_1268244 = 2.500000e-01f * _1268224;
float _1268235;
_1268235 = _1268234;
float _1268229;
_1268229 = 2.000000e-01f * _1268108;
float _1268240;
_1268240 = 2.500000e-01f * _1268166;
float _1268242;
_1268242 = 2.500000e-01f * _1268195;
float _1268238;
_1268238 = 2.500000e-01f * _1268137;
int _1268225;
_1268225 = _1014060_1268050.e3;
float _1268236;
_1268236 = 2.000000e-01f * _1268235;
float _1268237;
_1268237 = _1268229 + _1268236;
float _1268239;
_1268239 = 0.000000e+00f + _1268238;
int _1268226;
_1268226 = gid_y_1268083 * _1268225;
float _1268241;
_1268241 = _1268239 + _1268240;
int _1268227;
_1268227 = _1268226 + gid_x_1268076;
float _1268243;
_1268243 = _1268241 + _1268242;
float* idx_1268228;
idx_1268228 = _1014059_1268049 + _1268227;
float _1268245;
_1268245 = _1268243 + _1268244;
float val_1268246;
val_1268246 = _1268237 + _1268245;
*idx_1268228 = val_1268246;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1022765(float* _1022768_1275334, struct_Img_220118 _1022769_1275335, float* _1022770_1275336, float* _1022771_1275337, struct_Img_220118 _1022772_1275338, struct_Img_220118 _1022773_1275339) {
int _1275342;
int p_1275342;
int _1275345;
int p_1275345;
int _1275348;
int p_1275348;
int _1275351;
int p_1275351;
int _1275354;
int p_1275354;
int _1275357;
int p_1275357;
int _1275360;
int p_1275360;
struct_BoundaryMode_220129 bh_upper_1275371;
struct_BoundaryMode_220129 pbh_upper_1275371;
float _1275386;
float p_1275386;
float _1275389;
float p_1275389;
struct_BoundaryMode_220129 bh_upper_1275393;
struct_BoundaryMode_220129 pbh_upper_1275393;
float _1275404;
float p_1275404;
float _1275407;
float p_1275407;
struct_BoundaryMode_220129 bh_upper_1275413;
struct_BoundaryMode_220129 pbh_upper_1275413;
float _1275423;
float p_1275423;
float _1275426;
float p_1275426;
struct_BoundaryMode_220129 bh_upper_1275432;
struct_BoundaryMode_220129 pbh_upper_1275432;
float _1275442;
float p_1275442;
float _1275445;
float p_1275445;
struct_BoundaryMode_220129 bh_upper_1275449;
struct_BoundaryMode_220129 pbh_upper_1275449;
float _1275461;
float p_1275461;
float _1275464;
float p_1275464;
_1275342 = threadIdx_x();
p_1275342 = _1275342;
l1275340: ;
_1275342 = p_1275342;
_1275345 = blockDim_x();
p_1275345 = _1275345;
l1275343: ;
_1275345 = p_1275345;
_1275348 = blockIdx_x();
p_1275348 = _1275348;
l1275346: ;
_1275348 = p_1275348;
_1275351 = threadIdx_y();
p_1275351 = _1275351;
l1275349: ;
_1275351 = p_1275351;
_1275354 = blockDim_y();
p_1275354 = _1275354;
l1275352: ;
_1275354 = p_1275354;
_1275357 = blockIdx_y();
p_1275357 = _1275357;
l1275355: ;
_1275357 = p_1275357;
_1275360 = blockDim_y();
p_1275360 = _1275360;
l1275358: ;
_1275360 = p_1275360;
int _1275362;
_1275362 = _1022769_1275335.e1;
int _1275361;
_1275361 = _1022772_1275338.e1;
int _1275363;
_1275363 = _1275362 - 128;
int _1275365;
_1275365 = _1275345 * _1275348;
int _1275364;
_1275364 = _1275363 + _1275342;
int gid_x_1275366;
gid_x_1275366 = _1275364 + _1275365;
bool _1275367;
_1275367 = _1275361 <= gid_x_1275366;
union variant_220130 _1275494;
_1275494.qs32 = gid_x_1275366;
struct_BoundaryMode_220129 _1275495;
_1275495.e0 = 0;
_1275495.e1 = _1275494;
if (_1275367) goto l1275368; else goto l1275524;
l1275524: ;
pbh_upper_1275371 = _1275495;
goto l1275369;
l1275368: ;
union variant_220130 _1265919_3859;
_1265919_3859.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3861;
_1265920_3861.e0 = 1;
_1265920_3861.e1 = _1265919_3859;
pbh_upper_1275371 = _1265920_3861;
goto l1275369;
l1275369: ;
bh_upper_1275371 = pbh_upper_1275371;
int _1275375;
_1275375 = _1275354 * _1275357;
int _1275378;
_1275378 = _1022772_1275338.e3;
unsigned int _1275372;
_1275372 = bh_upper_1275371.e0;
int gid_y_1275376;
gid_y_1275376 = _1275351 + _1275375;
union variant_220130 _1275380;
_1275380 = bh_upper_1275371.e1;
bool _1275373;
_1275373 = _1275372 == 0;
int _1275377;
_1275377 = 1 + gid_y_1275376;
int _1275379;
_1275379 = _1275377 * _1275378;
if (_1275373) goto l1275374; else goto l1275519;
l1275519: ;
bool _1275520;
_1275520 = _1275372 == 1;
if (_1275520) goto l1275521; else goto l1275523;
l1275523: ;
// bottom: float r4_1265918_3871;
// bottom: p_1275389 = r4_1265918_3871;
goto l1275387;
l1275521: ;
float c_1275522;
c_1275522 = _1275380.pf32;
p_1275389 = c_1275522;
goto l1275387;
l1275374: ;
int x_1275381;
x_1275381 = _1275380.qs32;
int _1275382;
_1275382 = _1275379 + x_1275381;
float* idx_1275383;
idx_1275383 = _1022771_1275337 + _1275382;
_1275386 = __ldg(idx_1275383);
p_1275386 = _1275386;
l1275384: ;
_1275386 = p_1275386;
p_1275389 = _1275386;
goto l1275387;
l1275387: ;
_1275389 = p_1275389;
int _1275470;
_1275470 = _1022773_1275339.e3;
int _1275471;
_1275471 = _1275377 * _1275470;
int _1275472;
_1275472 = _1275471 + gid_x_1275366;
float* idx_1275473;
idx_1275473 = _1022768_1275334 + _1275472;
float _1275474;
_1275474 = *idx_1275473;
if (_1275367) goto l1275390; else goto l1275518;
l1275518: ;
pbh_upper_1275393 = _1275495;
goto l1275391;
l1275390: ;
union variant_220130 _1265919_3873;
_1265919_3873.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3875;
_1265920_3875.e0 = 1;
_1265920_3875.e1 = _1265919_3873;
pbh_upper_1275393 = _1265920_3875;
goto l1275391;
l1275391: ;
bh_upper_1275393 = pbh_upper_1275393;
union variant_220130 _1275398;
_1275398 = bh_upper_1275393.e1;
unsigned int _1275394;
_1275394 = bh_upper_1275393.e0;
bool _1275395;
_1275395 = _1275394 == 0;
if (_1275395) goto l1275396; else goto l1275512;
l1275512: ;
bool _1275513;
_1275513 = _1275394 == 1;
if (_1275513) goto l1275514; else goto l1275516;
l1275516: ;
// bottom: float r4_1265918_3883;
// bottom: p_1275407 = r4_1265918_3883;
goto l1275405;
l1275514: ;
float c_1275515;
c_1275515 = _1275398.pf32;
p_1275407 = c_1275515;
goto l1275405;
l1275396: ;
int x_1275399;
x_1275399 = _1275398.qs32;
int _1275397;
_1275397 = gid_y_1275376 * _1275378;
int _1275400;
_1275400 = _1275397 + x_1275399;
float* idx_1275401;
idx_1275401 = _1022771_1275337 + _1275400;
_1275404 = __ldg(idx_1275401);
p_1275404 = _1275404;
l1275402: ;
_1275404 = p_1275404;
p_1275407 = _1275404;
goto l1275405;
l1275405: ;
_1275407 = p_1275407;
int _1275408;
_1275408 = -1 + gid_x_1275366;
bool _1275409;
_1275409 = _1275361 <= _1275408;
if (_1275409) goto l1275410; else goto l1275509;
l1275509: ;
union variant_220130 _1275510;
_1275510.qs32 = _1275408;
struct_BoundaryMode_220129 _1275511;
_1275511.e0 = 0;
_1275511.e1 = _1275510;
pbh_upper_1275413 = _1275511;
goto l1275411;
l1275410: ;
union variant_220130 _1265919_3888;
_1265919_3888.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3890;
_1265920_3890.e0 = 1;
_1265920_3890.e1 = _1265919_3888;
pbh_upper_1275413 = _1265920_3890;
goto l1275411;
l1275411: ;
bh_upper_1275413 = pbh_upper_1275413;
unsigned int _1275414;
_1275414 = bh_upper_1275413.e0;
union variant_220130 _1275417;
_1275417 = bh_upper_1275413.e1;
bool _1275415;
_1275415 = _1275414 == 0;
if (_1275415) goto l1275416; else goto l1275504;
l1275504: ;
bool _1275505;
_1275505 = _1275414 == 1;
if (_1275505) goto l1275506; else goto l1275508;
l1275508: ;
// bottom: float r4_1265918_3898;
// bottom: p_1275426 = r4_1265918_3898;
goto l1275424;
l1275506: ;
float c_1275507;
c_1275507 = _1275417.pf32;
p_1275426 = c_1275507;
goto l1275424;
l1275416: ;
int x_1275418;
x_1275418 = _1275417.qs32;
int _1275419;
_1275419 = _1275379 + x_1275418;
float* idx_1275420;
idx_1275420 = _1022771_1275337 + _1275419;
_1275423 = __ldg(idx_1275420);
p_1275423 = _1275423;
l1275421: ;
_1275423 = p_1275423;
p_1275426 = _1275423;
goto l1275424;
l1275424: ;
_1275426 = p_1275426;
int _1275427;
_1275427 = 1 + gid_x_1275366;
bool _1275428;
_1275428 = _1275361 <= _1275427;
if (_1275428) goto l1275429; else goto l1275501;
l1275501: ;
union variant_220130 _1275502;
_1275502.qs32 = _1275427;
struct_BoundaryMode_220129 _1275503;
_1275503.e0 = 0;
_1275503.e1 = _1275502;
pbh_upper_1275432 = _1275503;
goto l1275430;
l1275429: ;
union variant_220130 _1265919_3903;
_1265919_3903.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3905;
_1265920_3905.e0 = 1;
_1265920_3905.e1 = _1265919_3903;
pbh_upper_1275432 = _1265920_3905;
goto l1275430;
l1275430: ;
bh_upper_1275432 = pbh_upper_1275432;
unsigned int _1275433;
_1275433 = bh_upper_1275432.e0;
union variant_220130 _1275436;
_1275436 = bh_upper_1275432.e1;
bool _1275434;
_1275434 = _1275433 == 0;
if (_1275434) goto l1275435; else goto l1275496;
l1275496: ;
bool _1275497;
_1275497 = _1275433 == 1;
if (_1275497) goto l1275498; else goto l1275500;
l1275500: ;
// bottom: float r4_1265918_3913;
// bottom: p_1275445 = r4_1265918_3913;
goto l1275443;
l1275498: ;
float c_1275499;
c_1275499 = _1275436.pf32;
p_1275445 = c_1275499;
goto l1275443;
l1275435: ;
int x_1275437;
x_1275437 = _1275436.qs32;
int _1275438;
_1275438 = _1275379 + x_1275437;
float* idx_1275439;
idx_1275439 = _1022771_1275337 + _1275438;
_1275442 = __ldg(idx_1275439);
p_1275442 = _1275442;
l1275440: ;
_1275442 = p_1275442;
p_1275445 = _1275442;
goto l1275443;
l1275443: ;
_1275445 = p_1275445;
if (_1275367) goto l1275446; else goto l1275493;
l1275493: ;
pbh_upper_1275449 = _1275495;
goto l1275447;
l1275446: ;
union variant_220130 _1265919_3914;
_1265919_3914.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3916;
_1265920_3916.e0 = 1;
_1265920_3916.e1 = _1265919_3914;
pbh_upper_1275449 = _1265920_3916;
goto l1275447;
l1275447: ;
bh_upper_1275449 = pbh_upper_1275449;
union variant_220130 _1275455;
_1275455 = bh_upper_1275449.e1;
unsigned int _1275450;
_1275450 = bh_upper_1275449.e0;
bool _1275451;
_1275451 = _1275450 == 0;
if (_1275451) goto l1275452; else goto l1275488;
l1275488: ;
bool _1275489;
_1275489 = _1275450 == 1;
if (_1275489) goto l1275490; else goto l1275492;
l1275492: ;
// bottom: float r4_1265918_3924;
// bottom: p_1275464 = r4_1265918_3924;
goto l1275462;
l1275490: ;
float c_1275491;
c_1275491 = _1275455.pf32;
p_1275464 = c_1275491;
goto l1275462;
l1275452: ;
int _1275453;
_1275453 = 2 + gid_y_1275376;
int _1275454;
_1275454 = _1275453 * _1275378;
int x_1275456;
x_1275456 = _1275455.qs32;
int _1275457;
_1275457 = _1275454 + x_1275456;
float* idx_1275458;
idx_1275458 = _1022771_1275337 + _1275457;
_1275461 = __ldg(idx_1275458);
p_1275461 = _1275461;
l1275459: ;
_1275461 = p_1275461;
p_1275464 = _1275461;
goto l1275462;
l1275462: ;
_1275464 = p_1275464;
float _1275480;
_1275480 = 2.500000e-01f * _1275426;
float _1275484;
_1275484 = 2.500000e-01f * _1275464;
float _1275475;
_1275475 = _1275474;
int _1275465;
_1275465 = _1022769_1275335.e3;
float _1275478;
_1275478 = 2.500000e-01f * _1275407;
float _1275469;
_1275469 = 2.000000e-01f * _1275389;
float _1275482;
_1275482 = 2.500000e-01f * _1275445;
float _1275476;
_1275476 = 2.000000e-01f * _1275475;
int _1275466;
_1275466 = _1275377 * _1275465;
float _1275479;
_1275479 = 0.000000e+00f + _1275478;
float _1275477;
_1275477 = _1275469 + _1275476;
int _1275467;
_1275467 = _1275466 + gid_x_1275366;
float _1275481;
_1275481 = _1275479 + _1275480;
float* idx_1275468;
idx_1275468 = _1022770_1275336 + _1275467;
float _1275483;
_1275483 = _1275481 + _1275482;
float _1275485;
_1275485 = _1275483 + _1275484;
float val_1275486;
val_1275486 = _1275477 + _1275485;
*idx_1275468 = val_1275486;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1005832(struct_Img_220118 _1005835_1267851, struct_Img_220118 _1005836_1267852, float* _1005837_1267853, struct_Img_220118 _1005838_1267854, float* _1005839_1267855, float* _1005840_1267856) {
int _1267859;
int p_1267859;
int _1267862;
int p_1267862;
int _1267865;
int p_1267865;
int _1267868;
int p_1267868;
int _1267871;
int p_1267871;
int _1267874;
int p_1267874;
int _1267877;
int p_1267877;
struct_BoundaryMode_220129 bh_lower_1267884;
struct_BoundaryMode_220129 pbh_lower_1267884;
float _1267899;
float p_1267899;
float _1267902;
float p_1267902;
struct_BoundaryMode_220129 bh_lower_1267908;
struct_BoundaryMode_220129 pbh_lower_1267908;
float _1267920;
float p_1267920;
float _1267923;
float p_1267923;
struct_BoundaryMode_220129 bh_lower_1267927;
struct_BoundaryMode_220129 pbh_lower_1267927;
float _1267939;
float p_1267939;
float _1267942;
float p_1267942;
struct_BoundaryMode_220129 bh_lower_1267946;
struct_BoundaryMode_220129 pbh_lower_1267946;
float _1267958;
float p_1267958;
float _1267961;
float p_1267961;
struct_BoundaryMode_220129 bh_lower_1267967;
struct_BoundaryMode_220129 pbh_lower_1267967;
float _1267979;
float p_1267979;
float _1267982;
float p_1267982;
_1267859 = threadIdx_x();
p_1267859 = _1267859;
l1267857: ;
_1267859 = p_1267859;
_1267862 = blockDim_x();
p_1267862 = _1267862;
l1267860: ;
_1267862 = p_1267862;
_1267865 = blockIdx_x();
p_1267865 = _1267865;
l1267863: ;
_1267865 = p_1267865;
_1267868 = threadIdx_y();
p_1267868 = _1267868;
l1267866: ;
_1267868 = p_1267868;
_1267871 = blockDim_y();
p_1267871 = _1267871;
l1267869: ;
_1267871 = p_1267871;
_1267874 = blockIdx_y();
p_1267874 = _1267874;
l1267872: ;
_1267874 = p_1267874;
_1267877 = blockDim_y();
p_1267877 = _1267877;
l1267875: ;
_1267877 = p_1267877;
int _1267878;
_1267878 = _1267871 * _1267874;
int gid_y_1267879;
gid_y_1267879 = _1267868 + _1267878;
bool _1267880;
_1267880 = gid_y_1267879 < 0;
union variant_220130 _1268022;
_1268022.qs32 = gid_y_1267879;
struct_BoundaryMode_220129 _1268023;
_1268023.e0 = 0;
_1268023.e1 = _1268022;
if (_1267880) goto l1267881; else goto l1268044;
l1268044: ;
pbh_lower_1267884 = _1268023;
goto l1267882;
l1267881: ;
union variant_220130 _1265919_3938;
_1265919_3938.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3940;
_1265920_3940.e0 = 1;
_1265920_3940.e1 = _1265919_3938;
pbh_lower_1267884 = _1265920_3940;
goto l1267882;
l1267882: ;
bh_lower_1267884 = pbh_lower_1267884;
int _1267890;
_1267890 = _1005836_1267852.e3;
union variant_220130 _1267888;
_1267888 = bh_lower_1267884.e1;
unsigned int _1267885;
_1267885 = bh_lower_1267884.e0;
int _1267892;
_1267892 = _1267862 * _1267865;
bool _1267886;
_1267886 = _1267885 == 0;
int gid_x_1267893;
gid_x_1267893 = _1267859 + _1267892;
if (_1267886) goto l1267887; else goto l1268039;
l1268039: ;
bool _1268040;
_1268040 = _1267885 == 1;
if (_1268040) goto l1268041; else goto l1268043;
l1268043: ;
// bottom: float r4_1265918_3949;
// bottom: p_1267902 = r4_1265918_3949;
goto l1267900;
l1268041: ;
float c_1268042;
c_1268042 = _1267888.pf32;
p_1267902 = c_1268042;
goto l1267900;
l1267887: ;
int y_1267889;
y_1267889 = _1267888.qs32;
int _1267891;
_1267891 = y_1267889 * _1267890;
int _1267894;
_1267894 = _1267891 + gid_x_1267893;
int _1267895;
_1267895 = 128 + _1267894;
float* idx_1267896;
idx_1267896 = _1005837_1267853 + _1267895;
_1267899 = __ldg(idx_1267896);
p_1267899 = _1267899;
l1267897: ;
_1267899 = p_1267899;
p_1267902 = _1267899;
goto l1267900;
l1267900: ;
_1267902 = p_1267902;
int _1267989;
_1267989 = _1005838_1267854.e3;
int _1267990;
_1267990 = gid_y_1267879 * _1267989;
int _1267903;
_1267903 = -1 + gid_y_1267879;
int _1267991;
_1267991 = _1267990 + gid_x_1267893;
bool _1267904;
_1267904 = _1267903 < 0;
int _1267992;
_1267992 = 128 + _1267991;
float* idx_1267993;
idx_1267993 = _1005840_1267856 + _1267992;
float _1267994;
_1267994 = *idx_1267993;
if (_1267904) goto l1267905; else goto l1268036;
l1268036: ;
union variant_220130 _1268037;
_1268037.qs32 = _1267903;
struct_BoundaryMode_220129 _1268038;
_1268038.e0 = 0;
_1268038.e1 = _1268037;
pbh_lower_1267908 = _1268038;
goto l1267906;
l1267905: ;
union variant_220130 _1265919_3958;
_1265919_3958.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3960;
_1265920_3960.e0 = 1;
_1265920_3960.e1 = _1265919_3958;
pbh_lower_1267908 = _1265920_3960;
goto l1267906;
l1267906: ;
bh_lower_1267908 = pbh_lower_1267908;
unsigned int _1267909;
_1267909 = bh_lower_1267908.e0;
union variant_220130 _1267912;
_1267912 = bh_lower_1267908.e1;
bool _1267910;
_1267910 = _1267909 == 0;
if (_1267910) goto l1267911; else goto l1268030;
l1268030: ;
bool _1268031;
_1268031 = _1267909 == 1;
if (_1268031) goto l1268032; else goto l1268034;
l1268034: ;
// bottom: float r4_1265918_3968;
// bottom: p_1267923 = r4_1265918_3968;
goto l1267921;
l1268032: ;
float c_1268033;
c_1268033 = _1267912.pf32;
p_1267923 = c_1268033;
goto l1267921;
l1267911: ;
int y_1267913;
y_1267913 = _1267912.qs32;
int _1267914;
_1267914 = y_1267913 * _1267890;
int _1267915;
_1267915 = _1267914 + gid_x_1267893;
int _1267916;
_1267916 = 128 + _1267915;
float* idx_1267917;
idx_1267917 = _1005837_1267853 + _1267916;
_1267920 = __ldg(idx_1267917);
p_1267920 = _1267920;
l1267918: ;
_1267920 = p_1267920;
p_1267923 = _1267920;
goto l1267921;
l1267921: ;
_1267923 = p_1267923;
if (_1267880) goto l1267924; else goto l1268029;
l1268029: ;
pbh_lower_1267927 = _1268023;
goto l1267925;
l1267924: ;
union variant_220130 _1265919_3970;
_1265919_3970.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3972;
_1265920_3972.e0 = 1;
_1265920_3972.e1 = _1265919_3970;
pbh_lower_1267927 = _1265920_3972;
goto l1267925;
l1267925: ;
bh_lower_1267927 = pbh_lower_1267927;
union variant_220130 _1267931;
_1267931 = bh_lower_1267927.e1;
unsigned int _1267928;
_1267928 = bh_lower_1267927.e0;
bool _1267929;
_1267929 = _1267928 == 0;
if (_1267929) goto l1267930; else goto l1268024;
l1268024: ;
bool _1268025;
_1268025 = _1267928 == 1;
if (_1268025) goto l1268026; else goto l1268028;
l1268028: ;
// bottom: float r4_1265918_3980;
// bottom: p_1267942 = r4_1265918_3980;
goto l1267940;
l1268026: ;
float c_1268027;
c_1268027 = _1267931.pf32;
p_1267942 = c_1268027;
goto l1267940;
l1267930: ;
int y_1267932;
y_1267932 = _1267931.qs32;
int _1267933;
_1267933 = y_1267932 * _1267890;
int _1267934;
_1267934 = _1267933 + gid_x_1267893;
int _1267935;
_1267935 = 127 + _1267934;
float* idx_1267936;
idx_1267936 = _1005837_1267853 + _1267935;
_1267939 = __ldg(idx_1267936);
p_1267939 = _1267939;
l1267937: ;
_1267939 = p_1267939;
p_1267942 = _1267939;
goto l1267940;
l1267940: ;
_1267942 = p_1267942;
if (_1267880) goto l1267943; else goto l1268021;
l1268021: ;
pbh_lower_1267946 = _1268023;
goto l1267944;
l1267943: ;
union variant_220130 _1265919_3982;
_1265919_3982.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_3984;
_1265920_3984.e0 = 1;
_1265920_3984.e1 = _1265919_3982;
pbh_lower_1267946 = _1265920_3984;
goto l1267944;
l1267944: ;
bh_lower_1267946 = pbh_lower_1267946;
union variant_220130 _1267950;
_1267950 = bh_lower_1267946.e1;
unsigned int _1267947;
_1267947 = bh_lower_1267946.e0;
bool _1267948;
_1267948 = _1267947 == 0;
if (_1267948) goto l1267949; else goto l1268016;
l1268016: ;
bool _1268017;
_1268017 = _1267947 == 1;
if (_1268017) goto l1268018; else goto l1268020;
l1268020: ;
// bottom: float r4_1265918_3992;
// bottom: p_1267961 = r4_1265918_3992;
goto l1267959;
l1268018: ;
float c_1268019;
c_1268019 = _1267950.pf32;
p_1267961 = c_1268019;
goto l1267959;
l1267949: ;
int y_1267951;
y_1267951 = _1267950.qs32;
int _1267952;
_1267952 = y_1267951 * _1267890;
int _1267953;
_1267953 = _1267952 + gid_x_1267893;
int _1267954;
_1267954 = 129 + _1267953;
float* idx_1267955;
idx_1267955 = _1005837_1267853 + _1267954;
_1267958 = __ldg(idx_1267955);
p_1267958 = _1267958;
l1267956: ;
_1267958 = p_1267958;
p_1267961 = _1267958;
goto l1267959;
l1267959: ;
_1267961 = p_1267961;
int _1267962;
_1267962 = 1 + gid_y_1267879;
bool _1267963;
_1267963 = _1267962 < 0;
if (_1267963) goto l1267964; else goto l1268013;
l1268013: ;
union variant_220130 _1268014;
_1268014.qs32 = _1267962;
struct_BoundaryMode_220129 _1268015;
_1268015.e0 = 0;
_1268015.e1 = _1268014;
pbh_lower_1267967 = _1268015;
goto l1267965;
l1267964: ;
union variant_220130 _1265919_3999;
_1265919_3999.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4001;
_1265920_4001.e0 = 1;
_1265920_4001.e1 = _1265919_3999;
pbh_lower_1267967 = _1265920_4001;
goto l1267965;
l1267965: ;
bh_lower_1267967 = pbh_lower_1267967;
union variant_220130 _1267971;
_1267971 = bh_lower_1267967.e1;
unsigned int _1267968;
_1267968 = bh_lower_1267967.e0;
bool _1267969;
_1267969 = _1267968 == 0;
if (_1267969) goto l1267970; else goto l1268008;
l1268008: ;
bool _1268009;
_1268009 = _1267968 == 1;
if (_1268009) goto l1268010; else goto l1268012;
l1268012: ;
// bottom: float r4_1265918_4009;
// bottom: p_1267982 = r4_1265918_4009;
goto l1267980;
l1268010: ;
float c_1268011;
c_1268011 = _1267971.pf32;
p_1267982 = c_1268011;
goto l1267980;
l1267970: ;
int y_1267972;
y_1267972 = _1267971.qs32;
int _1267973;
_1267973 = y_1267972 * _1267890;
int _1267974;
_1267974 = _1267973 + gid_x_1267893;
int _1267975;
_1267975 = 128 + _1267974;
float* idx_1267976;
idx_1267976 = _1005837_1267853 + _1267975;
_1267979 = __ldg(idx_1267976);
p_1267979 = _1267979;
l1267977: ;
_1267979 = p_1267979;
p_1267982 = _1267979;
goto l1267980;
l1267980: ;
_1267982 = p_1267982;
float _1268002;
_1268002 = 2.500000e-01f * _1267961;
float _1267998;
_1267998 = 2.500000e-01f * _1267923;
float _1268004;
_1268004 = 2.500000e-01f * _1267982;
int _1267983;
_1267983 = _1005835_1267851.e3;
float _1267995;
_1267995 = _1267994;
float _1267999;
_1267999 = 0.000000e+00f + _1267998;
float _1268000;
_1268000 = 2.500000e-01f * _1267942;
float _1267996;
_1267996 = 2.000000e-01f * _1267995;
float _1267988;
_1267988 = 2.000000e-01f * _1267902;
int _1267984;
_1267984 = gid_y_1267879 * _1267983;
float _1268001;
_1268001 = _1267999 + _1268000;
float _1267997;
_1267997 = _1267988 + _1267996;
int _1267985;
_1267985 = _1267984 + gid_x_1267893;
float _1268003;
_1268003 = _1268001 + _1268002;
int _1267986;
_1267986 = 128 + _1267985;
float _1268005;
_1268005 = _1268003 + _1268004;
float* idx_1267987;
idx_1267987 = _1005839_1267855 + _1267986;
float val_1268006;
val_1268006 = _1267997 + _1268005;
*idx_1267987 = val_1268006;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1025830(struct_Img_220118 _1025833_1275843, float* _1025834_1275844, struct_Img_220118 _1025835_1275845, float* _1025836_1275846, float* _1025837_1275847, struct_Img_220118 _1025838_1275848) {
int _1275851;
int p_1275851;
int _1275854;
int p_1275854;
int _1275857;
int p_1275857;
int _1275860;
int p_1275860;
int _1275863;
int p_1275863;
int _1275866;
int p_1275866;
int _1275869;
int p_1275869;
float _1275882;
float p_1275882;
float _1275896;
float p_1275896;
float _1275901;
float p_1275901;
float _1275906;
float p_1275906;
float _1275914;
float p_1275914;
_1275851 = threadIdx_x();
p_1275851 = _1275851;
l1275849: ;
_1275851 = p_1275851;
_1275854 = blockDim_x();
p_1275854 = _1275854;
l1275852: ;
_1275854 = p_1275854;
_1275857 = blockIdx_x();
p_1275857 = _1275857;
l1275855: ;
_1275857 = p_1275857;
_1275860 = threadIdx_y();
p_1275860 = _1275860;
l1275858: ;
_1275860 = p_1275860;
_1275863 = blockDim_y();
p_1275863 = _1275863;
l1275861: ;
_1275863 = p_1275863;
_1275866 = blockIdx_y();
p_1275866 = _1275866;
l1275864: ;
_1275866 = p_1275866;
_1275869 = blockDim_y();
p_1275869 = _1275869;
l1275867: ;
_1275869 = p_1275869;
int _1275875;
_1275875 = _1275854 * _1275857;
int gid_x_1275876;
gid_x_1275876 = _1275851 + _1275875;
int _1275870;
_1275870 = _1275863 * _1275866;
int _1275873;
_1275873 = _1025833_1275843.e3;
int gid_y_1275871;
gid_y_1275871 = _1275860 + _1275870;
int _1275872;
_1275872 = 1 + gid_y_1275871;
int _1275874;
_1275874 = _1275872 * _1275873;
int _1275877;
_1275877 = _1275874 + gid_x_1275876;
int _1275878;
_1275878 = 128 + _1275877;
float* idx_1275879;
idx_1275879 = _1025836_1275846 + _1275878;
_1275882 = __ldg(idx_1275879);
p_1275882 = _1275882;
l1275880: ;
_1275882 = p_1275882;
int _1275883;
_1275883 = _1025838_1275848.e3;
int _1275890;
_1275890 = gid_y_1275871 * _1275873;
int _1275884;
_1275884 = _1275872 * _1275883;
int _1275891;
_1275891 = _1275890 + gid_x_1275876;
int _1275885;
_1275885 = _1275884 + gid_x_1275876;
int _1275892;
_1275892 = 128 + _1275891;
int _1275886;
_1275886 = 128 + _1275885;
float* idx_1275893;
idx_1275893 = _1025836_1275846 + _1275892;
float* idx_1275887;
idx_1275887 = _1025834_1275844 + _1275886;
float _1275888;
_1275888 = *idx_1275887;
_1275896 = __ldg(idx_1275893);
p_1275896 = _1275896;
l1275894: ;
_1275896 = p_1275896;
int _1275897;
_1275897 = 127 + _1275877;
float* idx_1275898;
idx_1275898 = _1025836_1275846 + _1275897;
_1275901 = __ldg(idx_1275898);
p_1275901 = _1275901;
l1275899: ;
_1275901 = p_1275901;
int _1275902;
_1275902 = 129 + _1275877;
float* idx_1275903;
idx_1275903 = _1025836_1275846 + _1275902;
_1275906 = __ldg(idx_1275903);
p_1275906 = _1275906;
l1275904: ;
_1275906 = p_1275906;
int _1275907;
_1275907 = 2 + gid_y_1275871;
int _1275908;
_1275908 = _1275907 * _1275873;
int _1275909;
_1275909 = _1275908 + gid_x_1275876;
int _1275910;
_1275910 = 128 + _1275909;
float* idx_1275911;
idx_1275911 = _1025836_1275846 + _1275910;
_1275914 = __ldg(idx_1275911);
p_1275914 = _1275914;
l1275912: ;
_1275914 = p_1275914;
int _1275915;
_1275915 = _1025835_1275845.e3;
int _1275916;
_1275916 = _1275872 * _1275915;
int _1275917;
_1275917 = _1275916 + gid_x_1275876;
float _1275920;
_1275920 = 2.000000e-01f * _1275882;
float _1275921;
_1275921 = _1275888;
float _1275924;
_1275924 = 2.500000e-01f * _1275896;
float _1275930;
_1275930 = 2.500000e-01f * _1275914;
float _1275926;
_1275926 = 2.500000e-01f * _1275901;
int _1275918;
_1275918 = 128 + _1275917;
float _1275925;
_1275925 = 0.000000e+00f + _1275924;
float _1275928;
_1275928 = 2.500000e-01f * _1275906;
float _1275922;
_1275922 = 2.000000e-01f * _1275921;
float _1275927;
_1275927 = _1275925 + _1275926;
float* idx_1275919;
idx_1275919 = _1025837_1275847 + _1275918;
float _1275929;
_1275929 = _1275927 + _1275928;
float _1275923;
_1275923 = _1275920 + _1275922;
float _1275931;
_1275931 = _1275929 + _1275930;
float val_1275932;
val_1275932 = _1275923 + _1275931;
*idx_1275919 = val_1275932;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1044656(float* _1044659_1271898, struct_Img_220118 _1044660_1271899, struct_Img_220118 _1044661_1271900, float* _1044662_1271901, struct_Img_220118 _1044663_1271902, float* _1044664_1271903) {
int _1271906;
int p_1271906;
int _1271909;
int p_1271909;
int _1271912;
int p_1271912;
int _1271915;
int p_1271915;
int _1271918;
int p_1271918;
int _1271921;
int p_1271921;
int _1271924;
int p_1271924;
struct_BoundaryMode_220129 bh_upper_1271935;
struct_BoundaryMode_220129 pbh_upper_1271935;
float _1271950;
float p_1271950;
float _1271953;
float p_1271953;
struct_BoundaryMode_220129 bh_upper_1271959;
struct_BoundaryMode_220129 pbh_upper_1271959;
float _1271971;
float p_1271971;
float _1271974;
float p_1271974;
struct_BoundaryMode_220129 bh_upper_1271978;
struct_BoundaryMode_220129 pbh_upper_1271978;
float _1271990;
float p_1271990;
float _1271993;
float p_1271993;
struct_BoundaryMode_220129 bh_upper_1271997;
struct_BoundaryMode_220129 pbh_upper_1271997;
float _1272009;
float p_1272009;
float _1272012;
float p_1272012;
struct_BoundaryMode_220129 bh_upper_1272018;
struct_BoundaryMode_220129 pbh_upper_1272018;
float _1272030;
float p_1272030;
float _1272033;
float p_1272033;
_1271906 = threadIdx_x();
p_1271906 = _1271906;
l1271904: ;
_1271906 = p_1271906;
_1271909 = blockDim_x();
p_1271909 = _1271909;
l1271907: ;
_1271909 = p_1271909;
_1271912 = blockIdx_x();
p_1271912 = _1271912;
l1271910: ;
_1271912 = p_1271912;
_1271915 = threadIdx_y();
p_1271915 = _1271915;
l1271913: ;
_1271915 = p_1271915;
_1271918 = blockDim_y();
p_1271918 = _1271918;
l1271916: ;
_1271918 = p_1271918;
_1271921 = blockIdx_y();
p_1271921 = _1271921;
l1271919: ;
_1271921 = p_1271921;
_1271924 = blockDim_y();
p_1271924 = _1271924;
l1271922: ;
_1271924 = p_1271924;
int _1271926;
_1271926 = _1044663_1271902.e2;
int _1271925;
_1271925 = _1044660_1271899.e2;
int _1271929;
_1271929 = _1271918 * _1271921;
int _1271927;
_1271927 = _1271926 - 1;
int _1271928;
_1271928 = _1271927 + _1271915;
int gid_y_1271930;
gid_y_1271930 = _1271928 + _1271929;
bool _1271931;
_1271931 = _1271925 <= gid_y_1271930;
union variant_220130 _1272073;
_1272073.qs32 = gid_y_1271930;
struct_BoundaryMode_220129 _1272074;
_1272074.e0 = 0;
_1272074.e1 = _1272073;
if (_1271931) goto l1271932; else goto l1272095;
l1272095: ;
pbh_upper_1271935 = _1272074;
goto l1271933;
l1271932: ;
union variant_220130 _1265919_4045;
_1265919_4045.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4047;
_1265920_4047.e0 = 1;
_1265920_4047.e1 = _1265919_4045;
pbh_upper_1271935 = _1265920_4047;
goto l1271933;
l1271933: ;
bh_upper_1271935 = pbh_upper_1271935;
int _1271941;
_1271941 = _1044660_1271899.e3;
int _1271943;
_1271943 = _1271909 * _1271912;
unsigned int _1271936;
_1271936 = bh_upper_1271935.e0;
int gid_x_1271944;
gid_x_1271944 = _1271906 + _1271943;
bool _1271937;
_1271937 = _1271936 == 0;
union variant_220130 _1271939;
_1271939 = bh_upper_1271935.e1;
if (_1271937) goto l1271938; else goto l1272090;
l1272090: ;
bool _1272091;
_1272091 = _1271936 == 1;
if (_1272091) goto l1272092; else goto l1272094;
l1272094: ;
// bottom: float r4_1265918_4056;
// bottom: p_1271953 = r4_1265918_4056;
goto l1271951;
l1272092: ;
float c_1272093;
c_1272093 = _1271939.pf32;
p_1271953 = c_1272093;
goto l1271951;
l1271938: ;
int y_1271940;
y_1271940 = _1271939.qs32;
int _1271942;
_1271942 = y_1271940 * _1271941;
int _1271945;
_1271945 = _1271942 + gid_x_1271944;
int _1271946;
_1271946 = 128 + _1271945;
float* idx_1271947;
idx_1271947 = _1044659_1271898 + _1271946;
_1271950 = __ldg(idx_1271947);
p_1271950 = _1271950;
l1271948: ;
_1271950 = p_1271950;
p_1271953 = _1271950;
goto l1271951;
l1271951: ;
_1271953 = p_1271953;
int _1272040;
_1272040 = _1044661_1271900.e3;
int _1271954;
_1271954 = -1 + gid_y_1271930;
int _1272041;
_1272041 = gid_y_1271930 * _1272040;
bool _1271955;
_1271955 = _1271925 <= _1271954;
int _1272042;
_1272042 = _1272041 + gid_x_1271944;
int _1272043;
_1272043 = 128 + _1272042;
float* idx_1272044;
idx_1272044 = _1044664_1271903 + _1272043;
float _1272045;
_1272045 = *idx_1272044;
if (_1271955) goto l1271956; else goto l1272087;
l1272087: ;
union variant_220130 _1272088;
_1272088.qs32 = _1271954;
struct_BoundaryMode_220129 _1272089;
_1272089.e0 = 0;
_1272089.e1 = _1272088;
pbh_upper_1271959 = _1272089;
goto l1271957;
l1271956: ;
union variant_220130 _1265919_4064;
_1265919_4064.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4066;
_1265920_4066.e0 = 1;
_1265920_4066.e1 = _1265919_4064;
pbh_upper_1271959 = _1265920_4066;
goto l1271957;
l1271957: ;
bh_upper_1271959 = pbh_upper_1271959;
unsigned int _1271960;
_1271960 = bh_upper_1271959.e0;
union variant_220130 _1271963;
_1271963 = bh_upper_1271959.e1;
bool _1271961;
_1271961 = _1271960 == 0;
if (_1271961) goto l1271962; else goto l1272081;
l1272081: ;
bool _1272082;
_1272082 = _1271960 == 1;
if (_1272082) goto l1272083; else goto l1272085;
l1272085: ;
// bottom: float r4_1265918_4074;
// bottom: p_1271974 = r4_1265918_4074;
goto l1271972;
l1272083: ;
float c_1272084;
c_1272084 = _1271963.pf32;
p_1271974 = c_1272084;
goto l1271972;
l1271962: ;
int y_1271964;
y_1271964 = _1271963.qs32;
int _1271965;
_1271965 = y_1271964 * _1271941;
int _1271966;
_1271966 = _1271965 + gid_x_1271944;
int _1271967;
_1271967 = 128 + _1271966;
float* idx_1271968;
idx_1271968 = _1044659_1271898 + _1271967;
_1271971 = __ldg(idx_1271968);
p_1271971 = _1271971;
l1271969: ;
_1271971 = p_1271971;
p_1271974 = _1271971;
goto l1271972;
l1271972: ;
_1271974 = p_1271974;
if (_1271931) goto l1271975; else goto l1272080;
l1272080: ;
pbh_upper_1271978 = _1272074;
goto l1271976;
l1271975: ;
union variant_220130 _1265919_4076;
_1265919_4076.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4078;
_1265920_4078.e0 = 1;
_1265920_4078.e1 = _1265919_4076;
pbh_upper_1271978 = _1265920_4078;
goto l1271976;
l1271976: ;
bh_upper_1271978 = pbh_upper_1271978;
unsigned int _1271979;
_1271979 = bh_upper_1271978.e0;
union variant_220130 _1271982;
_1271982 = bh_upper_1271978.e1;
bool _1271980;
_1271980 = _1271979 == 0;
if (_1271980) goto l1271981; else goto l1272075;
l1272075: ;
bool _1272076;
_1272076 = _1271979 == 1;
if (_1272076) goto l1272077; else goto l1272079;
l1272079: ;
// bottom: float r4_1265918_4086;
// bottom: p_1271993 = r4_1265918_4086;
goto l1271991;
l1272077: ;
float c_1272078;
c_1272078 = _1271982.pf32;
p_1271993 = c_1272078;
goto l1271991;
l1271981: ;
int y_1271983;
y_1271983 = _1271982.qs32;
int _1271984;
_1271984 = y_1271983 * _1271941;
int _1271985;
_1271985 = _1271984 + gid_x_1271944;
int _1271986;
_1271986 = 127 + _1271985;
float* idx_1271987;
idx_1271987 = _1044659_1271898 + _1271986;
_1271990 = __ldg(idx_1271987);
p_1271990 = _1271990;
l1271988: ;
_1271990 = p_1271990;
p_1271993 = _1271990;
goto l1271991;
l1271991: ;
_1271993 = p_1271993;
if (_1271931) goto l1271994; else goto l1272072;
l1272072: ;
pbh_upper_1271997 = _1272074;
goto l1271995;
l1271994: ;
union variant_220130 _1265919_4088;
_1265919_4088.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4090;
_1265920_4090.e0 = 1;
_1265920_4090.e1 = _1265919_4088;
pbh_upper_1271997 = _1265920_4090;
goto l1271995;
l1271995: ;
bh_upper_1271997 = pbh_upper_1271997;
union variant_220130 _1272001;
_1272001 = bh_upper_1271997.e1;
unsigned int _1271998;
_1271998 = bh_upper_1271997.e0;
bool _1271999;
_1271999 = _1271998 == 0;
if (_1271999) goto l1272000; else goto l1272067;
l1272067: ;
bool _1272068;
_1272068 = _1271998 == 1;
if (_1272068) goto l1272069; else goto l1272071;
l1272071: ;
// bottom: float r4_1265918_4098;
// bottom: p_1272012 = r4_1265918_4098;
goto l1272010;
l1272069: ;
float c_1272070;
c_1272070 = _1272001.pf32;
p_1272012 = c_1272070;
goto l1272010;
l1272000: ;
int y_1272002;
y_1272002 = _1272001.qs32;
int _1272003;
_1272003 = y_1272002 * _1271941;
int _1272004;
_1272004 = _1272003 + gid_x_1271944;
int _1272005;
_1272005 = 129 + _1272004;
float* idx_1272006;
idx_1272006 = _1044659_1271898 + _1272005;
_1272009 = __ldg(idx_1272006);
p_1272009 = _1272009;
l1272007: ;
_1272009 = p_1272009;
p_1272012 = _1272009;
goto l1272010;
l1272010: ;
_1272012 = p_1272012;
int _1272013;
_1272013 = 1 + gid_y_1271930;
bool _1272014;
_1272014 = _1271925 <= _1272013;
if (_1272014) goto l1272015; else goto l1272064;
l1272064: ;
union variant_220130 _1272065;
_1272065.qs32 = _1272013;
struct_BoundaryMode_220129 _1272066;
_1272066.e0 = 0;
_1272066.e1 = _1272065;
pbh_upper_1272018 = _1272066;
goto l1272016;
l1272015: ;
union variant_220130 _1265919_4104;
_1265919_4104.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4106;
_1265920_4106.e0 = 1;
_1265920_4106.e1 = _1265919_4104;
pbh_upper_1272018 = _1265920_4106;
goto l1272016;
l1272016: ;
bh_upper_1272018 = pbh_upper_1272018;
union variant_220130 _1272022;
_1272022 = bh_upper_1272018.e1;
unsigned int _1272019;
_1272019 = bh_upper_1272018.e0;
bool _1272020;
_1272020 = _1272019 == 0;
if (_1272020) goto l1272021; else goto l1272059;
l1272059: ;
bool _1272060;
_1272060 = _1272019 == 1;
if (_1272060) goto l1272061; else goto l1272063;
l1272063: ;
// bottom: float r4_1265918_4114;
// bottom: p_1272033 = r4_1265918_4114;
goto l1272031;
l1272061: ;
float c_1272062;
c_1272062 = _1272022.pf32;
p_1272033 = c_1272062;
goto l1272031;
l1272021: ;
int y_1272023;
y_1272023 = _1272022.qs32;
int _1272024;
_1272024 = y_1272023 * _1271941;
int _1272025;
_1272025 = _1272024 + gid_x_1271944;
int _1272026;
_1272026 = 128 + _1272025;
float* idx_1272027;
idx_1272027 = _1044659_1271898 + _1272026;
_1272030 = __ldg(idx_1272027);
p_1272030 = _1272030;
l1272028: ;
_1272030 = p_1272030;
p_1272033 = _1272030;
goto l1272031;
l1272031: ;
_1272033 = p_1272033;
float _1272055;
_1272055 = 2.500000e-01f * _1272033;
float _1272053;
_1272053 = 2.500000e-01f * _1272012;
float _1272039;
_1272039 = 2.000000e-01f * _1271953;
int _1272034;
_1272034 = _1044663_1271902.e3;
int _1272035;
_1272035 = gid_y_1271930 * _1272034;
float _1272051;
_1272051 = 2.500000e-01f * _1271993;
float _1272049;
_1272049 = 2.500000e-01f * _1271974;
float _1272050;
_1272050 = 0.000000e+00f + _1272049;
float _1272046;
_1272046 = _1272045;
int _1272036;
_1272036 = _1272035 + gid_x_1271944;
float _1272052;
_1272052 = _1272050 + _1272051;
float _1272047;
_1272047 = 2.000000e-01f * _1272046;
int _1272037;
_1272037 = 128 + _1272036;
float _1272054;
_1272054 = _1272052 + _1272053;
float _1272048;
_1272048 = _1272039 + _1272047;
float* idx_1272038;
idx_1272038 = _1044662_1271901 + _1272037;
float _1272056;
_1272056 = _1272054 + _1272055;
float val_1272057;
val_1272057 = _1272048 + _1272056;
*idx_1272038 = val_1272057;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1022222(float* _1022225_1272661, struct_Img_220118 _1022226_1272662, float* _1022227_1272663, float* _1022228_1272664, struct_Img_220118 _1022229_1272665, struct_Img_220118 _1022230_1272666) {
int _1272669;
int p_1272669;
int _1272672;
int p_1272672;
int _1272675;
int p_1272675;
int _1272678;
int p_1272678;
int _1272681;
int p_1272681;
int _1272684;
int p_1272684;
int _1272687;
int p_1272687;
struct_BoundaryMode_220129 bh_upper_1272698;
struct_BoundaryMode_220129 pbh_upper_1272698;
struct_BoundaryMode_220129 bh_lower_1272705;
struct_BoundaryMode_220129 pbh_lower_1272705;
float _1272722;
float p_1272722;
float _1272725;
float p_1272725;
struct_BoundaryMode_220129 bh_upper_1272729;
struct_BoundaryMode_220129 pbh_upper_1272729;
struct_BoundaryMode_220129 bh_lower_1272735;
struct_BoundaryMode_220129 pbh_lower_1272735;
float _1272751;
float p_1272751;
float _1272754;
float p_1272754;
struct_BoundaryMode_220129 bh_upper_1272760;
struct_BoundaryMode_220129 pbh_upper_1272760;
struct_BoundaryMode_220129 bh_lower_1272764;
struct_BoundaryMode_220129 pbh_lower_1272764;
float _1272780;
float p_1272780;
float _1272783;
float p_1272783;
struct_BoundaryMode_220129 bh_upper_1272789;
struct_BoundaryMode_220129 pbh_upper_1272789;
struct_BoundaryMode_220129 bh_lower_1272793;
struct_BoundaryMode_220129 pbh_lower_1272793;
float _1272809;
float p_1272809;
float _1272812;
float p_1272812;
struct_BoundaryMode_220129 bh_upper_1272816;
struct_BoundaryMode_220129 pbh_upper_1272816;
struct_BoundaryMode_220129 bh_lower_1272822;
struct_BoundaryMode_220129 pbh_lower_1272822;
float _1272838;
float p_1272838;
float _1272841;
float p_1272841;
_1272669 = threadIdx_x();
p_1272669 = _1272669;
l1272667: ;
_1272669 = p_1272669;
_1272672 = blockDim_x();
p_1272672 = _1272672;
l1272670: ;
_1272672 = p_1272672;
_1272675 = blockIdx_x();
p_1272675 = _1272675;
l1272673: ;
_1272675 = p_1272675;
_1272678 = threadIdx_y();
p_1272678 = _1272678;
l1272676: ;
_1272678 = p_1272678;
_1272681 = blockDim_y();
p_1272681 = _1272681;
l1272679: ;
_1272681 = p_1272681;
_1272684 = blockIdx_y();
p_1272684 = _1272684;
l1272682: ;
_1272684 = p_1272684;
_1272687 = blockDim_y();
p_1272687 = _1272687;
l1272685: ;
_1272687 = p_1272687;
int _1272692;
_1272692 = _1272672 * _1272675;
int _1272688;
_1272688 = _1022229_1272665.e1;
int _1272689;
_1272689 = _1022226_1272662.e1;
int _1272690;
_1272690 = _1272689 - 128;
int _1272691;
_1272691 = _1272690 + _1272669;
int gid_x_1272693;
gid_x_1272693 = _1272691 + _1272692;
bool _1272694;
_1272694 = _1272688 <= gid_x_1272693;
union variant_220130 _1272878;
_1272878.qs32 = gid_x_1272693;
struct_BoundaryMode_220129 _1272879;
_1272879.e0 = 0;
_1272879.e1 = _1272878;
if (_1272694) goto l1272695; else goto l1272932;
l1272932: ;
pbh_upper_1272698 = _1272879;
goto l1272696;
l1272695: ;
union variant_220130 _1265919_4131;
_1265919_4131.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4133;
_1265920_4133.e0 = 1;
_1265920_4133.e1 = _1265919_4131;
pbh_upper_1272698 = _1265920_4133;
goto l1272696;
l1272696: ;
bh_upper_1272698 = pbh_upper_1272698;
int _1272699;
_1272699 = _1272681 * _1272684;
int gid_y_1272700;
gid_y_1272700 = _1272678 + _1272699;
union variant_220130 _1272890;
_1272890.qs32 = gid_y_1272700;
bool _1272701;
_1272701 = gid_y_1272700 < 0;
struct_BoundaryMode_220129 _1272891;
_1272891.e0 = 0;
_1272891.e1 = _1272890;
if (_1272701) goto l1272702; else goto l1272931;
l1272931: ;
pbh_lower_1272705 = _1272891;
goto l1272703;
l1272702: ;
union variant_220130 _1265919_4141;
_1265919_4141.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4143;
_1265920_4143.e0 = 1;
_1265920_4143.e1 = _1265919_4141;
pbh_lower_1272705 = _1265920_4143;
goto l1272703;
l1272703: ;
bh_lower_1272705 = pbh_lower_1272705;
union variant_220130 _1272716;
_1272716 = bh_upper_1272698.e1;
unsigned int _1272706;
_1272706 = bh_upper_1272698.e0;
int _1272714;
_1272714 = _1022229_1272665.e3;
unsigned int _1272708;
_1272708 = bh_lower_1272705.e0;
union variant_220130 _1272712;
_1272712 = bh_lower_1272705.e1;
bool _1272709;
_1272709 = _1272708 == 0;
bool _1272707;
_1272707 = _1272706 == 0;
bool _1272710;
_1272710 = _1272707 & _1272709;
if (_1272710) goto l1272711; else goto l1272922;
l1272922: ;
bool _1272923;
_1272923 = _1272706 == 1;
if (_1272923) goto l1272924; else goto l1272926;
l1272926: ;
bool _1272927;
_1272927 = _1272708 == 1;
if (_1272927) goto l1272928; else goto l1272930;
l1272930: ;
// bottom: float r4_1265918_4156;
// bottom: p_1272725 = r4_1265918_4156;
goto l1272723;
l1272928: ;
float c_1272929;
c_1272929 = _1272712.pf32;
p_1272725 = c_1272929;
goto l1272723;
l1272924: ;
float c_1272925;
c_1272925 = _1272716.pf32;
p_1272725 = c_1272925;
goto l1272723;
l1272711: ;
int x_1272717;
x_1272717 = _1272716.qs32;
int y_1272713;
y_1272713 = _1272712.qs32;
int _1272715;
_1272715 = y_1272713 * _1272714;
int _1272718;
_1272718 = _1272715 + x_1272717;
float* idx_1272719;
idx_1272719 = _1022228_1272664 + _1272718;
_1272722 = __ldg(idx_1272719);
p_1272722 = _1272722;
l1272720: ;
_1272722 = p_1272722;
p_1272725 = _1272722;
goto l1272723;
l1272723: ;
_1272725 = p_1272725;
int _1272847;
_1272847 = _1022230_1272666.e3;
int _1272848;
_1272848 = gid_y_1272700 * _1272847;
int _1272849;
_1272849 = _1272848 + gid_x_1272693;
float* idx_1272850;
idx_1272850 = _1022225_1272661 + _1272849;
float _1272851;
_1272851 = *idx_1272850;
if (_1272694) goto l1272726; else goto l1272921;
l1272921: ;
pbh_upper_1272729 = _1272879;
goto l1272727;
l1272726: ;
union variant_220130 _1265919_4158;
_1265919_4158.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4160;
_1265920_4160.e0 = 1;
_1265920_4160.e1 = _1265919_4158;
pbh_upper_1272729 = _1265920_4160;
goto l1272727;
l1272727: ;
bh_upper_1272729 = pbh_upper_1272729;
int _1272730;
_1272730 = -1 + gid_y_1272700;
bool _1272731;
_1272731 = _1272730 < 0;
if (_1272731) goto l1272732; else goto l1272917;
l1272917: ;
union variant_220130 _1272918;
_1272918.qs32 = _1272730;
struct_BoundaryMode_220129 _1272919;
_1272919.e0 = 0;
_1272919.e1 = _1272918;
pbh_lower_1272735 = _1272919;
goto l1272733;
l1272732: ;
union variant_220130 _1265919_4169;
_1265919_4169.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4171;
_1265920_4171.e0 = 1;
_1265920_4171.e1 = _1265919_4169;
pbh_lower_1272735 = _1265920_4171;
goto l1272733;
l1272733: ;
bh_lower_1272735 = pbh_lower_1272735;
unsigned int _1272738;
_1272738 = bh_lower_1272735.e0;
union variant_220130 _1272742;
_1272742 = bh_lower_1272735.e1;
union variant_220130 _1272745;
_1272745 = bh_upper_1272729.e1;
bool _1272739;
_1272739 = _1272738 == 0;
unsigned int _1272736;
_1272736 = bh_upper_1272729.e0;
bool _1272737;
_1272737 = _1272736 == 0;
bool _1272740;
_1272740 = _1272737 & _1272739;
if (_1272740) goto l1272741; else goto l1272908;
l1272908: ;
bool _1272909;
_1272909 = _1272736 == 1;
if (_1272909) goto l1272910; else goto l1272912;
l1272912: ;
bool _1272913;
_1272913 = _1272738 == 1;
if (_1272913) goto l1272914; else goto l1272916;
l1272916: ;
// bottom: float r4_1265918_4183;
// bottom: p_1272754 = r4_1265918_4183;
goto l1272752;
l1272914: ;
float c_1272915;
c_1272915 = _1272742.pf32;
p_1272754 = c_1272915;
goto l1272752;
l1272910: ;
float c_1272911;
c_1272911 = _1272745.pf32;
p_1272754 = c_1272911;
goto l1272752;
l1272741: ;
int y_1272743;
y_1272743 = _1272742.qs32;
int x_1272746;
x_1272746 = _1272745.qs32;
int _1272744;
_1272744 = y_1272743 * _1272714;
int _1272747;
_1272747 = _1272744 + x_1272746;
float* idx_1272748;
idx_1272748 = _1022228_1272664 + _1272747;
_1272751 = __ldg(idx_1272748);
p_1272751 = _1272751;
l1272749: ;
_1272751 = p_1272751;
p_1272754 = _1272751;
goto l1272752;
l1272752: ;
_1272754 = p_1272754;
int _1272755;
_1272755 = -1 + gid_x_1272693;
bool _1272756;
_1272756 = _1272688 <= _1272755;
if (_1272756) goto l1272757; else goto l1272905;
l1272905: ;
union variant_220130 _1272906;
_1272906.qs32 = _1272755;
struct_BoundaryMode_220129 _1272907;
_1272907.e0 = 0;
_1272907.e1 = _1272906;
pbh_upper_1272760 = _1272907;
goto l1272758;
l1272757: ;
union variant_220130 _1265919_4188;
_1265919_4188.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4190;
_1265920_4190.e0 = 1;
_1265920_4190.e1 = _1265919_4188;
pbh_upper_1272760 = _1265920_4190;
goto l1272758;
l1272758: ;
bh_upper_1272760 = pbh_upper_1272760;
if (_1272701) goto l1272761; else goto l1272904;
l1272904: ;
pbh_lower_1272764 = _1272891;
goto l1272762;
l1272761: ;
union variant_220130 _1265919_4194;
_1265919_4194.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4196;
_1265920_4196.e0 = 1;
_1265920_4196.e1 = _1265919_4194;
pbh_lower_1272764 = _1265920_4196;
goto l1272762;
l1272762: ;
bh_lower_1272764 = pbh_lower_1272764;
unsigned int _1272767;
_1272767 = bh_lower_1272764.e0;
bool _1272768;
_1272768 = _1272767 == 0;
union variant_220130 _1272774;
_1272774 = bh_upper_1272760.e1;
unsigned int _1272765;
_1272765 = bh_upper_1272760.e0;
union variant_220130 _1272771;
_1272771 = bh_lower_1272764.e1;
bool _1272766;
_1272766 = _1272765 == 0;
bool _1272769;
_1272769 = _1272766 & _1272768;
if (_1272769) goto l1272770; else goto l1272895;
l1272895: ;
bool _1272896;
_1272896 = _1272765 == 1;
if (_1272896) goto l1272897; else goto l1272899;
l1272899: ;
bool _1272900;
_1272900 = _1272767 == 1;
if (_1272900) goto l1272901; else goto l1272903;
l1272903: ;
// bottom: float r4_1265918_4208;
// bottom: p_1272783 = r4_1265918_4208;
goto l1272781;
l1272901: ;
float c_1272902;
c_1272902 = _1272771.pf32;
p_1272783 = c_1272902;
goto l1272781;
l1272897: ;
float c_1272898;
c_1272898 = _1272774.pf32;
p_1272783 = c_1272898;
goto l1272781;
l1272770: ;
int x_1272775;
x_1272775 = _1272774.qs32;
int y_1272772;
y_1272772 = _1272771.qs32;
int _1272773;
_1272773 = y_1272772 * _1272714;
int _1272776;
_1272776 = _1272773 + x_1272775;
float* idx_1272777;
idx_1272777 = _1022228_1272664 + _1272776;
_1272780 = __ldg(idx_1272777);
p_1272780 = _1272780;
l1272778: ;
_1272780 = p_1272780;
p_1272783 = _1272780;
goto l1272781;
l1272781: ;
_1272783 = p_1272783;
int _1272784;
_1272784 = 1 + gid_x_1272693;
bool _1272785;
_1272785 = _1272688 <= _1272784;
if (_1272785) goto l1272786; else goto l1272892;
l1272892: ;
union variant_220130 _1272893;
_1272893.qs32 = _1272784;
struct_BoundaryMode_220129 _1272894;
_1272894.e0 = 0;
_1272894.e1 = _1272893;
pbh_upper_1272789 = _1272894;
goto l1272787;
l1272786: ;
union variant_220130 _1265919_4213;
_1265919_4213.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4215;
_1265920_4215.e0 = 1;
_1265920_4215.e1 = _1265919_4213;
pbh_upper_1272789 = _1265920_4215;
goto l1272787;
l1272787: ;
bh_upper_1272789 = pbh_upper_1272789;
if (_1272701) goto l1272790; else goto l1272889;
l1272889: ;
pbh_lower_1272793 = _1272891;
goto l1272791;
l1272790: ;
union variant_220130 _1265919_4219;
_1265919_4219.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4221;
_1265920_4221.e0 = 1;
_1265920_4221.e1 = _1265919_4219;
pbh_lower_1272793 = _1265920_4221;
goto l1272791;
l1272791: ;
bh_lower_1272793 = pbh_lower_1272793;
union variant_220130 _1272803;
_1272803 = bh_upper_1272789.e1;
unsigned int _1272794;
_1272794 = bh_upper_1272789.e0;
bool _1272795;
_1272795 = _1272794 == 0;
union variant_220130 _1272800;
_1272800 = bh_lower_1272793.e1;
unsigned int _1272796;
_1272796 = bh_lower_1272793.e0;
bool _1272797;
_1272797 = _1272796 == 0;
bool _1272798;
_1272798 = _1272795 & _1272797;
if (_1272798) goto l1272799; else goto l1272880;
l1272880: ;
bool _1272881;
_1272881 = _1272794 == 1;
if (_1272881) goto l1272882; else goto l1272884;
l1272884: ;
bool _1272885;
_1272885 = _1272796 == 1;
if (_1272885) goto l1272886; else goto l1272888;
l1272888: ;
// bottom: float r4_1265918_4233;
// bottom: p_1272812 = r4_1265918_4233;
goto l1272810;
l1272886: ;
float c_1272887;
c_1272887 = _1272800.pf32;
p_1272812 = c_1272887;
goto l1272810;
l1272882: ;
float c_1272883;
c_1272883 = _1272803.pf32;
p_1272812 = c_1272883;
goto l1272810;
l1272799: ;
int y_1272801;
y_1272801 = _1272800.qs32;
int x_1272804;
x_1272804 = _1272803.qs32;
int _1272802;
_1272802 = y_1272801 * _1272714;
int _1272805;
_1272805 = _1272802 + x_1272804;
float* idx_1272806;
idx_1272806 = _1022228_1272664 + _1272805;
_1272809 = __ldg(idx_1272806);
p_1272809 = _1272809;
l1272807: ;
_1272809 = p_1272809;
p_1272812 = _1272809;
goto l1272810;
l1272810: ;
_1272812 = p_1272812;
if (_1272694) goto l1272813; else goto l1272877;
l1272877: ;
pbh_upper_1272816 = _1272879;
goto l1272814;
l1272813: ;
union variant_220130 _1265919_4234;
_1265919_4234.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4236;
_1265920_4236.e0 = 1;
_1265920_4236.e1 = _1265919_4234;
pbh_upper_1272816 = _1265920_4236;
goto l1272814;
l1272814: ;
bh_upper_1272816 = pbh_upper_1272816;
int _1272817;
_1272817 = 1 + gid_y_1272700;
bool _1272818;
_1272818 = _1272817 < 0;
if (_1272818) goto l1272819; else goto l1272874;
l1272874: ;
union variant_220130 _1272875;
_1272875.qs32 = _1272817;
struct_BoundaryMode_220129 _1272876;
_1272876.e0 = 0;
_1272876.e1 = _1272875;
pbh_lower_1272822 = _1272876;
goto l1272820;
l1272819: ;
union variant_220130 _1265919_4245;
_1265919_4245.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4247;
_1265920_4247.e0 = 1;
_1265920_4247.e1 = _1265919_4245;
pbh_lower_1272822 = _1265920_4247;
goto l1272820;
l1272820: ;
bh_lower_1272822 = pbh_lower_1272822;
unsigned int _1272825;
_1272825 = bh_lower_1272822.e0;
unsigned int _1272823;
_1272823 = bh_upper_1272816.e0;
bool _1272826;
_1272826 = _1272825 == 0;
union variant_220130 _1272829;
_1272829 = bh_lower_1272822.e1;
union variant_220130 _1272832;
_1272832 = bh_upper_1272816.e1;
bool _1272824;
_1272824 = _1272823 == 0;
bool _1272827;
_1272827 = _1272824 & _1272826;
if (_1272827) goto l1272828; else goto l1272865;
l1272865: ;
bool _1272866;
_1272866 = _1272823 == 1;
if (_1272866) goto l1272867; else goto l1272869;
l1272869: ;
bool _1272870;
_1272870 = _1272825 == 1;
if (_1272870) goto l1272871; else goto l1272873;
l1272873: ;
// bottom: float r4_1265918_4259;
// bottom: p_1272841 = r4_1265918_4259;
goto l1272839;
l1272871: ;
float c_1272872;
c_1272872 = _1272829.pf32;
p_1272841 = c_1272872;
goto l1272839;
l1272867: ;
float c_1272868;
c_1272868 = _1272832.pf32;
p_1272841 = c_1272868;
goto l1272839;
l1272828: ;
int y_1272830;
y_1272830 = _1272829.qs32;
int x_1272833;
x_1272833 = _1272832.qs32;
int _1272831;
_1272831 = y_1272830 * _1272714;
int _1272834;
_1272834 = _1272831 + x_1272833;
float* idx_1272835;
idx_1272835 = _1022228_1272664 + _1272834;
_1272838 = __ldg(idx_1272835);
p_1272838 = _1272838;
l1272836: ;
_1272838 = p_1272838;
p_1272841 = _1272838;
goto l1272839;
l1272839: ;
_1272841 = p_1272841;
float _1272861;
_1272861 = 2.500000e-01f * _1272841;
float _1272855;
_1272855 = 2.500000e-01f * _1272754;
float _1272852;
_1272852 = _1272851;
float _1272857;
_1272857 = 2.500000e-01f * _1272783;
float _1272856;
_1272856 = 0.000000e+00f + _1272855;
int _1272842;
_1272842 = _1022226_1272662.e3;
float _1272859;
_1272859 = 2.500000e-01f * _1272812;
int _1272843;
_1272843 = gid_y_1272700 * _1272842;
float _1272846;
_1272846 = 2.000000e-01f * _1272725;
float _1272858;
_1272858 = _1272856 + _1272857;
float _1272853;
_1272853 = 2.000000e-01f * _1272852;
float _1272860;
_1272860 = _1272858 + _1272859;
int _1272844;
_1272844 = _1272843 + gid_x_1272693;
float _1272854;
_1272854 = _1272846 + _1272853;
float _1272862;
_1272862 = _1272860 + _1272861;
float* idx_1272845;
idx_1272845 = _1022227_1272663 + _1272844;
float val_1272863;
val_1272863 = _1272854 + _1272862;
*idx_1272845 = val_1272863;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1026192(struct_Img_220118 _1026195_1274192, float* _1026196_1274193, struct_Img_220118 _1026197_1274194, float* _1026198_1274195, float* _1026199_1274196, struct_Img_220118 _1026200_1274197) {
int _1274200;
int p_1274200;
int _1274203;
int p_1274203;
int _1274206;
int p_1274206;
int _1274209;
int p_1274209;
int _1274212;
int p_1274212;
int _1274215;
int p_1274215;
int _1274218;
int p_1274218;
struct_BoundaryMode_220129 bh_upper_1274229;
struct_BoundaryMode_220129 pbh_upper_1274229;
float _1274244;
float p_1274244;
float _1274247;
float p_1274247;
struct_BoundaryMode_220129 bh_upper_1274253;
struct_BoundaryMode_220129 pbh_upper_1274253;
float _1274265;
float p_1274265;
float _1274268;
float p_1274268;
struct_BoundaryMode_220129 bh_upper_1274272;
struct_BoundaryMode_220129 pbh_upper_1274272;
float _1274284;
float p_1274284;
float _1274287;
float p_1274287;
struct_BoundaryMode_220129 bh_upper_1274291;
struct_BoundaryMode_220129 pbh_upper_1274291;
float _1274303;
float p_1274303;
float _1274306;
float p_1274306;
struct_BoundaryMode_220129 bh_upper_1274312;
struct_BoundaryMode_220129 pbh_upper_1274312;
float _1274324;
float p_1274324;
float _1274327;
float p_1274327;
_1274200 = threadIdx_x();
p_1274200 = _1274200;
l1274198: ;
_1274200 = p_1274200;
_1274203 = blockDim_x();
p_1274203 = _1274203;
l1274201: ;
_1274203 = p_1274203;
_1274206 = blockIdx_x();
p_1274206 = _1274206;
l1274204: ;
_1274206 = p_1274206;
_1274209 = threadIdx_y();
p_1274209 = _1274209;
l1274207: ;
_1274209 = p_1274209;
_1274212 = blockDim_y();
p_1274212 = _1274212;
l1274210: ;
_1274212 = p_1274212;
_1274215 = blockIdx_y();
p_1274215 = _1274215;
l1274213: ;
_1274215 = p_1274215;
_1274218 = blockDim_y();
p_1274218 = _1274218;
l1274216: ;
_1274218 = p_1274218;
int _1274223;
_1274223 = _1274212 * _1274215;
int _1274219;
_1274219 = _1026195_1274192.e2;
int _1274220;
_1274220 = _1026197_1274194.e2;
int _1274221;
_1274221 = _1274220 - 1;
int _1274222;
_1274222 = _1274221 + _1274209;
int gid_y_1274224;
gid_y_1274224 = _1274222 + _1274223;
union variant_220130 _1274367;
_1274367.qs32 = gid_y_1274224;
bool _1274225;
_1274225 = _1274219 <= gid_y_1274224;
struct_BoundaryMode_220129 _1274368;
_1274368.e0 = 0;
_1274368.e1 = _1274367;
if (_1274225) goto l1274226; else goto l1274389;
l1274389: ;
pbh_upper_1274229 = _1274368;
goto l1274227;
l1274226: ;
union variant_220130 _1265919_4274;
_1265919_4274.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4276;
_1265920_4276.e0 = 1;
_1265920_4276.e1 = _1265919_4274;
pbh_upper_1274229 = _1265920_4276;
goto l1274227;
l1274227: ;
bh_upper_1274229 = pbh_upper_1274229;
unsigned int _1274230;
_1274230 = bh_upper_1274229.e0;
bool _1274231;
_1274231 = _1274230 == 0;
union variant_220130 _1274233;
_1274233 = bh_upper_1274229.e1;
int _1274235;
_1274235 = _1026195_1274192.e3;
int _1274237;
_1274237 = _1274203 * _1274206;
int gid_x_1274238;
gid_x_1274238 = _1274200 + _1274237;
if (_1274231) goto l1274232; else goto l1274384;
l1274384: ;
bool _1274385;
_1274385 = _1274230 == 1;
if (_1274385) goto l1274386; else goto l1274388;
l1274388: ;
// bottom: float r4_1265918_4285;
// bottom: p_1274247 = r4_1265918_4285;
goto l1274245;
l1274386: ;
float c_1274387;
c_1274387 = _1274233.pf32;
p_1274247 = c_1274387;
goto l1274245;
l1274232: ;
int y_1274234;
y_1274234 = _1274233.qs32;
int _1274236;
_1274236 = y_1274234 * _1274235;
int _1274239;
_1274239 = _1274236 + gid_x_1274238;
int _1274240;
_1274240 = 128 + _1274239;
float* idx_1274241;
idx_1274241 = _1026198_1274195 + _1274240;
_1274244 = __ldg(idx_1274241);
p_1274244 = _1274244;
l1274242: ;
_1274244 = p_1274244;
p_1274247 = _1274244;
goto l1274245;
l1274245: ;
_1274247 = p_1274247;
int _1274248;
_1274248 = -1 + gid_y_1274224;
int _1274334;
_1274334 = _1026200_1274197.e3;
int _1274335;
_1274335 = gid_y_1274224 * _1274334;
bool _1274249;
_1274249 = _1274219 <= _1274248;
int _1274336;
_1274336 = _1274335 + gid_x_1274238;
int _1274337;
_1274337 = 128 + _1274336;
float* idx_1274338;
idx_1274338 = _1026196_1274193 + _1274337;
float _1274339;
_1274339 = *idx_1274338;
if (_1274249) goto l1274250; else goto l1274381;
l1274381: ;
union variant_220130 _1274382;
_1274382.qs32 = _1274248;
struct_BoundaryMode_220129 _1274383;
_1274383.e0 = 0;
_1274383.e1 = _1274382;
pbh_upper_1274253 = _1274383;
goto l1274251;
l1274250: ;
union variant_220130 _1265919_4293;
_1265919_4293.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4295;
_1265920_4295.e0 = 1;
_1265920_4295.e1 = _1265919_4293;
pbh_upper_1274253 = _1265920_4295;
goto l1274251;
l1274251: ;
bh_upper_1274253 = pbh_upper_1274253;
unsigned int _1274254;
_1274254 = bh_upper_1274253.e0;
union variant_220130 _1274257;
_1274257 = bh_upper_1274253.e1;
bool _1274255;
_1274255 = _1274254 == 0;
if (_1274255) goto l1274256; else goto l1274375;
l1274375: ;
bool _1274376;
_1274376 = _1274254 == 1;
if (_1274376) goto l1274377; else goto l1274379;
l1274379: ;
// bottom: float r4_1265918_4303;
// bottom: p_1274268 = r4_1265918_4303;
goto l1274266;
l1274377: ;
float c_1274378;
c_1274378 = _1274257.pf32;
p_1274268 = c_1274378;
goto l1274266;
l1274256: ;
int y_1274258;
y_1274258 = _1274257.qs32;
int _1274259;
_1274259 = y_1274258 * _1274235;
int _1274260;
_1274260 = _1274259 + gid_x_1274238;
int _1274261;
_1274261 = 128 + _1274260;
float* idx_1274262;
idx_1274262 = _1026198_1274195 + _1274261;
_1274265 = __ldg(idx_1274262);
p_1274265 = _1274265;
l1274263: ;
_1274265 = p_1274265;
p_1274268 = _1274265;
goto l1274266;
l1274266: ;
_1274268 = p_1274268;
if (_1274225) goto l1274269; else goto l1274374;
l1274374: ;
pbh_upper_1274272 = _1274368;
goto l1274270;
l1274269: ;
union variant_220130 _1265919_4305;
_1265919_4305.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4307;
_1265920_4307.e0 = 1;
_1265920_4307.e1 = _1265919_4305;
pbh_upper_1274272 = _1265920_4307;
goto l1274270;
l1274270: ;
bh_upper_1274272 = pbh_upper_1274272;
union variant_220130 _1274276;
_1274276 = bh_upper_1274272.e1;
unsigned int _1274273;
_1274273 = bh_upper_1274272.e0;
bool _1274274;
_1274274 = _1274273 == 0;
if (_1274274) goto l1274275; else goto l1274369;
l1274369: ;
bool _1274370;
_1274370 = _1274273 == 1;
if (_1274370) goto l1274371; else goto l1274373;
l1274373: ;
// bottom: float r4_1265918_4315;
// bottom: p_1274287 = r4_1265918_4315;
goto l1274285;
l1274371: ;
float c_1274372;
c_1274372 = _1274276.pf32;
p_1274287 = c_1274372;
goto l1274285;
l1274275: ;
int y_1274277;
y_1274277 = _1274276.qs32;
int _1274278;
_1274278 = y_1274277 * _1274235;
int _1274279;
_1274279 = _1274278 + gid_x_1274238;
int _1274280;
_1274280 = 127 + _1274279;
float* idx_1274281;
idx_1274281 = _1026198_1274195 + _1274280;
_1274284 = __ldg(idx_1274281);
p_1274284 = _1274284;
l1274282: ;
_1274284 = p_1274284;
p_1274287 = _1274284;
goto l1274285;
l1274285: ;
_1274287 = p_1274287;
if (_1274225) goto l1274288; else goto l1274366;
l1274366: ;
pbh_upper_1274291 = _1274368;
goto l1274289;
l1274288: ;
union variant_220130 _1265919_4317;
_1265919_4317.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4319;
_1265920_4319.e0 = 1;
_1265920_4319.e1 = _1265919_4317;
pbh_upper_1274291 = _1265920_4319;
goto l1274289;
l1274289: ;
bh_upper_1274291 = pbh_upper_1274291;
unsigned int _1274292;
_1274292 = bh_upper_1274291.e0;
bool _1274293;
_1274293 = _1274292 == 0;
union variant_220130 _1274295;
_1274295 = bh_upper_1274291.e1;
if (_1274293) goto l1274294; else goto l1274361;
l1274361: ;
bool _1274362;
_1274362 = _1274292 == 1;
if (_1274362) goto l1274363; else goto l1274365;
l1274365: ;
// bottom: float r4_1265918_4327;
// bottom: p_1274306 = r4_1265918_4327;
goto l1274304;
l1274363: ;
float c_1274364;
c_1274364 = _1274295.pf32;
p_1274306 = c_1274364;
goto l1274304;
l1274294: ;
int y_1274296;
y_1274296 = _1274295.qs32;
int _1274297;
_1274297 = y_1274296 * _1274235;
int _1274298;
_1274298 = _1274297 + gid_x_1274238;
int _1274299;
_1274299 = 129 + _1274298;
float* idx_1274300;
idx_1274300 = _1026198_1274195 + _1274299;
_1274303 = __ldg(idx_1274300);
p_1274303 = _1274303;
l1274301: ;
_1274303 = p_1274303;
p_1274306 = _1274303;
goto l1274304;
l1274304: ;
_1274306 = p_1274306;
int _1274307;
_1274307 = 1 + gid_y_1274224;
bool _1274308;
_1274308 = _1274219 <= _1274307;
if (_1274308) goto l1274309; else goto l1274358;
l1274358: ;
union variant_220130 _1274359;
_1274359.qs32 = _1274307;
struct_BoundaryMode_220129 _1274360;
_1274360.e0 = 0;
_1274360.e1 = _1274359;
pbh_upper_1274312 = _1274360;
goto l1274310;
l1274309: ;
union variant_220130 _1265919_4333;
_1265919_4333.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4335;
_1265920_4335.e0 = 1;
_1265920_4335.e1 = _1265919_4333;
pbh_upper_1274312 = _1265920_4335;
goto l1274310;
l1274310: ;
bh_upper_1274312 = pbh_upper_1274312;
union variant_220130 _1274316;
_1274316 = bh_upper_1274312.e1;
unsigned int _1274313;
_1274313 = bh_upper_1274312.e0;
bool _1274314;
_1274314 = _1274313 == 0;
if (_1274314) goto l1274315; else goto l1274353;
l1274353: ;
bool _1274354;
_1274354 = _1274313 == 1;
if (_1274354) goto l1274355; else goto l1274357;
l1274357: ;
// bottom: float r4_1265918_4343;
// bottom: p_1274327 = r4_1265918_4343;
goto l1274325;
l1274355: ;
float c_1274356;
c_1274356 = _1274316.pf32;
p_1274327 = c_1274356;
goto l1274325;
l1274315: ;
int y_1274317;
y_1274317 = _1274316.qs32;
int _1274318;
_1274318 = y_1274317 * _1274235;
int _1274319;
_1274319 = _1274318 + gid_x_1274238;
int _1274320;
_1274320 = 128 + _1274319;
float* idx_1274321;
idx_1274321 = _1026198_1274195 + _1274320;
_1274324 = __ldg(idx_1274321);
p_1274324 = _1274324;
l1274322: ;
_1274324 = p_1274324;
p_1274327 = _1274324;
goto l1274325;
l1274325: ;
_1274327 = p_1274327;
float _1274340;
_1274340 = _1274339;
float _1274341;
_1274341 = 2.000000e-01f * _1274340;
int _1274328;
_1274328 = _1026197_1274194.e3;
float _1274333;
_1274333 = 2.000000e-01f * _1274247;
float _1274347;
_1274347 = 2.500000e-01f * _1274306;
float _1274345;
_1274345 = 2.500000e-01f * _1274287;
float _1274343;
_1274343 = 2.500000e-01f * _1274268;
int _1274329;
_1274329 = gid_y_1274224 * _1274328;
float _1274349;
_1274349 = 2.500000e-01f * _1274327;
float _1274342;
_1274342 = _1274333 + _1274341;
float _1274344;
_1274344 = 0.000000e+00f + _1274343;
int _1274330;
_1274330 = _1274329 + gid_x_1274238;
float _1274346;
_1274346 = _1274344 + _1274345;
int _1274331;
_1274331 = 128 + _1274330;
float _1274348;
_1274348 = _1274346 + _1274347;
float* idx_1274332;
idx_1274332 = _1026199_1274196 + _1274331;
float _1274350;
_1274350 = _1274348 + _1274349;
float val_1274351;
val_1274351 = _1274342 + _1274350;
*idx_1274332 = val_1274351;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_998397(float* _998400_1269808, float* _998401_1269809, int _998402_1269810) {
int _1269813;
int p_1269813;
int _1269816;
int p_1269816;
int _1269819;
int p_1269819;
int _1269822;
int p_1269822;
int _1269825;
int p_1269825;
int _1269828;
int p_1269828;
int _1269831;
int p_1269831;
int converge_1269839;
int pconverge_1269839;
int converge_1269846;
int pconverge_1269846;
float _1269852;
float p_1269852;
int converge_1269857;
int pconverge_1269857;
int converge_1269861;
int pconverge_1269861;
float _1269867;
float p_1269867;
int converge_1269870;
int pconverge_1269870;
int converge_1269873;
int pconverge_1269873;
float _1269879;
float p_1269879;
int converge_1269884;
int pconverge_1269884;
int converge_1269887;
int pconverge_1269887;
float _1269893;
float p_1269893;
int converge_1269896;
int pconverge_1269896;
int converge_1269901;
int pconverge_1269901;
float _1269907;
float p_1269907;
_1269813 = threadIdx_x();
p_1269813 = _1269813;
l1269811: ;
_1269813 = p_1269813;
_1269816 = blockDim_x();
p_1269816 = _1269816;
l1269814: ;
_1269816 = p_1269816;
_1269819 = blockIdx_x();
p_1269819 = _1269819;
l1269817: ;
_1269819 = p_1269819;
_1269822 = threadIdx_y();
p_1269822 = _1269822;
l1269820: ;
_1269822 = p_1269822;
_1269825 = blockDim_y();
p_1269825 = _1269825;
l1269823: ;
_1269825 = p_1269825;
_1269828 = blockIdx_y();
p_1269828 = _1269828;
l1269826: ;
_1269828 = p_1269828;
_1269831 = blockDim_y();
p_1269831 = _1269831;
l1269829: ;
_1269831 = p_1269831;
int _1269834;
_1269834 = _1269816 * _1269819;
int _1269832;
_1269832 = _998402_1269810 - 128;
int _1269833;
_1269833 = _1269832 + _1269813;
int gid_x_1269835;
gid_x_1269835 = _1269833 + _1269834;
bool _1269836;
_1269836 = _998402_1269810 <= gid_x_1269835;
int _1269880;
_1269880 = 1 + gid_x_1269835;
int _1269935;
_1269935 = _1269880 - _998402_1269810;
int _1269936;
_1269936 = _998402_1269810 - _1269935;
if (_1269836) goto l1269837; else goto l1269954;
l1269954: ;
pconverge_1269839 = gid_x_1269835;
goto l1269838;
l1269837: ;
pconverge_1269839 = _1269936;
goto l1269838;
l1269838: ;
converge_1269839 = pconverge_1269839;
int _1269840;
_1269840 = _1269825 * _1269828;
int gid_y_1269841;
gid_y_1269841 = _1269822 + _1269840;
int _1269842;
_1269842 = -1 + gid_y_1269841;
bool _1269843;
_1269843 = _1269842 < 0;
if (_1269843) goto l1269844; else goto l1269953;
l1269953: ;
pconverge_1269846 = _1269842;
goto l1269845;
l1269844: ;
int _1269951;
_1269951 = 0 - _1269842;
int _1269952;
_1269952 = _1269951 - 1;
pconverge_1269846 = _1269952;
goto l1269845;
l1269845: ;
converge_1269846 = pconverge_1269846;
int _1269847;
_1269847 = converge_1269846 * _998402_1269810;
int _1269848;
_1269848 = _1269847 + converge_1269839;
float* idx_1269849;
idx_1269849 = _998400_1269808 + _1269848;
_1269852 = __ldg(idx_1269849);
p_1269852 = _1269852;
l1269850: ;
_1269852 = p_1269852;
int _1269853;
_1269853 = -1 + gid_x_1269835;
bool _1269854;
_1269854 = _998402_1269810 <= _1269853;
if (_1269854) goto l1269855; else goto l1269950;
l1269950: ;
pconverge_1269857 = _1269853;
goto l1269856;
l1269855: ;
int _1269948;
_1269948 = gid_x_1269835 - _998402_1269810;
int _1269949;
_1269949 = _998402_1269810 - _1269948;
pconverge_1269857 = _1269949;
goto l1269856;
l1269856: ;
converge_1269857 = pconverge_1269857;
int _1269938;
_1269938 = 0 - gid_y_1269841;
int _1269939;
_1269939 = _1269938 - 1;
bool _1269858;
_1269858 = gid_y_1269841 < 0;
if (_1269858) goto l1269859; else goto l1269947;
l1269947: ;
pconverge_1269861 = gid_y_1269841;
goto l1269860;
l1269859: ;
pconverge_1269861 = _1269939;
goto l1269860;
l1269860: ;
converge_1269861 = pconverge_1269861;
int _1269862;
_1269862 = converge_1269861 * _998402_1269810;
int _1269863;
_1269863 = _1269862 + converge_1269857;
float* idx_1269864;
idx_1269864 = _998400_1269808 + _1269863;
_1269867 = __ldg(idx_1269864);
p_1269867 = _1269867;
l1269865: ;
_1269867 = p_1269867;
if (_1269836) goto l1269868; else goto l1269946;
l1269946: ;
pconverge_1269870 = gid_x_1269835;
goto l1269869;
l1269868: ;
pconverge_1269870 = _1269936;
goto l1269869;
l1269869: ;
converge_1269870 = pconverge_1269870;
if (_1269858) goto l1269871; else goto l1269945;
l1269945: ;
pconverge_1269873 = gid_y_1269841;
goto l1269872;
l1269871: ;
pconverge_1269873 = _1269939;
goto l1269872;
l1269872: ;
converge_1269873 = pconverge_1269873;
int _1269874;
_1269874 = converge_1269873 * _998402_1269810;
int _1269875;
_1269875 = _1269874 + converge_1269870;
float* idx_1269876;
idx_1269876 = _998400_1269808 + _1269875;
_1269879 = __ldg(idx_1269876);
p_1269879 = _1269879;
l1269877: ;
_1269879 = p_1269879;
bool _1269881;
_1269881 = _998402_1269810 <= _1269880;
if (_1269881) goto l1269882; else goto l1269944;
l1269944: ;
pconverge_1269884 = _1269880;
goto l1269883;
l1269882: ;
int _1269941;
_1269941 = 2 + gid_x_1269835;
int _1269942;
_1269942 = _1269941 - _998402_1269810;
int _1269943;
_1269943 = _998402_1269810 - _1269942;
pconverge_1269884 = _1269943;
goto l1269883;
l1269883: ;
converge_1269884 = pconverge_1269884;
if (_1269858) goto l1269885; else goto l1269940;
l1269940: ;
pconverge_1269887 = gid_y_1269841;
goto l1269886;
l1269885: ;
pconverge_1269887 = _1269939;
goto l1269886;
l1269886: ;
converge_1269887 = pconverge_1269887;
int _1269888;
_1269888 = converge_1269887 * _998402_1269810;
int _1269889;
_1269889 = _1269888 + converge_1269884;
float* idx_1269890;
idx_1269890 = _998400_1269808 + _1269889;
_1269893 = __ldg(idx_1269890);
p_1269893 = _1269893;
l1269891: ;
_1269893 = p_1269893;
if (_1269836) goto l1269894; else goto l1269937;
l1269937: ;
pconverge_1269896 = gid_x_1269835;
goto l1269895;
l1269894: ;
pconverge_1269896 = _1269936;
goto l1269895;
l1269895: ;
converge_1269896 = pconverge_1269896;
int _1269897;
_1269897 = 1 + gid_y_1269841;
bool _1269898;
_1269898 = _1269897 < 0;
if (_1269898) goto l1269899; else goto l1269934;
l1269934: ;
pconverge_1269901 = _1269897;
goto l1269900;
l1269899: ;
int _1269932;
_1269932 = 0 - _1269897;
int _1269933;
_1269933 = _1269932 - 1;
pconverge_1269901 = _1269933;
goto l1269900;
l1269900: ;
converge_1269901 = pconverge_1269901;
int _1269902;
_1269902 = converge_1269901 * _998402_1269810;
int _1269903;
_1269903 = _1269902 + converge_1269896;
float* idx_1269904;
idx_1269904 = _998400_1269808 + _1269903;
_1269907 = __ldg(idx_1269904);
p_1269907 = _1269907;
l1269905: ;
_1269907 = p_1269907;
float _1269925;
_1269925 = -4.000000e+00f * _1269879;
float _1269920;
_1269920 = 1.000000e+00f * _1269852;
int _1269910;
_1269910 = 4 * _998402_1269810;
float _1269922;
_1269922 = 1.000000e+00f * _1269867;
float _1269921;
_1269921 = 0.000000e+00f + _1269920;
float _1269923;
_1269923 = _1269921 + _1269922;
float _1269929;
_1269929 = 1.000000e+00f * _1269907;
int _1269911;
_1269911 = 64 + _1269910;
float _1269927;
_1269927 = 1.000000e+00f * _1269893;
float _1269926;
_1269926 = _1269923 + _1269925;
int _1269912;
_1269912 = _1269911 - 1;
float _1269928;
_1269928 = _1269926 + _1269927;
int _1269913;
_1269913 = _1269912 / 64;
float _1269930;
_1269930 = _1269928 + _1269929;
int _1269914;
_1269914 = 64 * _1269913;
int stride_1269915;
stride_1269915 = _1269914 / 4;
int _1269916;
_1269916 = gid_y_1269841 * stride_1269915;
int _1269917;
_1269917 = _1269916 + gid_x_1269835;
float* idx_1269918;
idx_1269918 = _998401_1269809 + _1269917;
*idx_1269918 = _1269930;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1003232(struct_Img_220118 _1003235_1265726, float* _1003236_1265727, struct_Img_220118 _1003237_1265728, float* _1003238_1265729, float* _1003239_1265730, struct_Img_220118 _1003240_1265731) {
int _1265737;
int p_1265737;
int _1265743;
int p_1265743;
int _1265749;
int p_1265749;
int _1265755;
int p_1265755;
int _1265761;
int p_1265761;
int _1265767;
int p_1265767;
int _1265770;
int p_1265770;
struct_BoundaryMode_220129 bh_upper_1265783;
struct_BoundaryMode_220129 pbh_upper_1265783;
float _1265805;
float p_1265805;
float _1265808;
float p_1265808;
struct_BoundaryMode_220129 bh_upper_1265812;
struct_BoundaryMode_220129 pbh_upper_1265812;
float _1265823;
float p_1265823;
float _1265826;
float p_1265826;
struct_BoundaryMode_220129 bh_upper_1265833;
struct_BoundaryMode_220129 pbh_upper_1265833;
float _1265843;
float p_1265843;
float _1265846;
float p_1265846;
struct_BoundaryMode_220129 bh_upper_1265852;
struct_BoundaryMode_220129 pbh_upper_1265852;
float _1265862;
float p_1265862;
float _1265865;
float p_1265865;
struct_BoundaryMode_220129 bh_upper_1265869;
struct_BoundaryMode_220129 pbh_upper_1265869;
float _1265882;
float p_1265882;
float _1265885;
float p_1265885;
_1265737 = threadIdx_x();
p_1265737 = _1265737;
l1265735: ;
_1265737 = p_1265737;
_1265743 = blockDim_x();
p_1265743 = _1265743;
l1265741: ;
_1265743 = p_1265743;
_1265749 = blockIdx_x();
p_1265749 = _1265749;
l1265747: ;
_1265749 = p_1265749;
_1265755 = threadIdx_y();
p_1265755 = _1265755;
l1265753: ;
_1265755 = p_1265755;
_1265761 = blockDim_y();
p_1265761 = _1265761;
l1265759: ;
_1265761 = p_1265761;
_1265767 = blockIdx_y();
p_1265767 = _1265767;
l1265765: ;
_1265767 = p_1265767;
_1265770 = blockDim_y();
p_1265770 = _1265770;
l1265768: ;
_1265770 = p_1265770;
int _1265773;
_1265773 = _1003240_1265731.e1;
int _1265777;
_1265777 = _1265743 * _1265749;
int _1265772;
_1265772 = _1003235_1265726.e1;
int _1265775;
_1265775 = _1265773 - 128;
int _1265776;
_1265776 = _1265775 + _1265737;
int gid_x_1265778;
gid_x_1265778 = _1265776 + _1265777;
union variant_220130 _1265922;
_1265922.qs32 = gid_x_1265778;
bool _1265779;
_1265779 = _1265772 <= gid_x_1265778;
struct_BoundaryMode_220129 _1265923;
_1265923.e0 = 0;
_1265923.e1 = _1265922;
if (_1265779) goto l1265780; else goto l1265952;
l1265952: ;
pbh_upper_1265783 = _1265923;
goto l1265781;
l1265780: ;
union variant_220130 _1265919_4387;
_1265919_4387.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4389;
_1265920_4389.e0 = 1;
_1265920_4389.e1 = _1265919_4387;
pbh_upper_1265783 = _1265920_4389;
goto l1265781;
l1265781: ;
bh_upper_1265783 = pbh_upper_1265783;
unsigned int _1265785;
_1265785 = bh_upper_1265783.e0;
bool _1265786;
_1265786 = _1265785 == 0;
union variant_220130 _1265799;
_1265799 = bh_upper_1265783.e1;
int _1265797;
_1265797 = _1003235_1265726.e3;
int _1265793;
_1265793 = _1265761 * _1265767;
int gid_y_1265794;
gid_y_1265794 = _1265755 + _1265793;
int _1265795;
_1265795 = 1 + gid_y_1265794;
int _1265798;
_1265798 = _1265795 * _1265797;
if (_1265786) goto l1265787; else goto l1265947;
l1265947: ;
bool _1265948;
_1265948 = _1265785 == 1;
if (_1265948) goto l1265949; else goto l1265951;
l1265951: ;
// bottom: float r4_1265918_4399;
// bottom: p_1265808 = r4_1265918_4399;
goto l1265806;
l1265949: ;
float c_1265950;
c_1265950 = _1265799.pf32;
p_1265808 = c_1265950;
goto l1265806;
l1265787: ;
int x_1265800;
x_1265800 = _1265799.qs32;
int _1265801;
_1265801 = _1265798 + x_1265800;
float* idx_1265802;
idx_1265802 = _1003236_1265727 + _1265801;
_1265805 = __ldg(idx_1265802);
p_1265805 = _1265805;
l1265803: ;
_1265805 = p_1265805;
p_1265808 = _1265805;
goto l1265806;
l1265806: ;
_1265808 = p_1265808;
int _1265893;
_1265893 = _1003237_1265728.e3;
int _1265894;
_1265894 = _1265795 * _1265893;
int _1265895;
_1265895 = _1265894 + gid_x_1265778;
float* idx_1265896;
idx_1265896 = _1003239_1265730 + _1265895;
float _1265897;
_1265897 = *idx_1265896;
if (_1265779) goto l1265809; else goto l1265946;
l1265946: ;
pbh_upper_1265812 = _1265923;
goto l1265810;
l1265809: ;
union variant_220130 _1265919_4401;
_1265919_4401.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4403;
_1265920_4403.e0 = 1;
_1265920_4403.e1 = _1265919_4401;
pbh_upper_1265812 = _1265920_4403;
goto l1265810;
l1265810: ;
bh_upper_1265812 = pbh_upper_1265812;
union variant_220130 _1265817;
_1265817 = bh_upper_1265812.e1;
unsigned int _1265813;
_1265813 = bh_upper_1265812.e0;
bool _1265814;
_1265814 = _1265813 == 0;
if (_1265814) goto l1265815; else goto l1265940;
l1265940: ;
bool _1265941;
_1265941 = _1265813 == 1;
if (_1265941) goto l1265942; else goto l1265944;
l1265944: ;
// bottom: float r4_1265918_4411;
// bottom: p_1265826 = r4_1265918_4411;
goto l1265824;
l1265942: ;
float c_1265943;
c_1265943 = _1265817.pf32;
p_1265826 = c_1265943;
goto l1265824;
l1265815: ;
int _1265816;
_1265816 = gid_y_1265794 * _1265797;
int x_1265818;
x_1265818 = _1265817.qs32;
int _1265819;
_1265819 = _1265816 + x_1265818;
float* idx_1265820;
idx_1265820 = _1003236_1265727 + _1265819;
_1265823 = __ldg(idx_1265820);
p_1265823 = _1265823;
l1265821: ;
_1265823 = p_1265823;
p_1265826 = _1265823;
goto l1265824;
l1265824: ;
_1265826 = p_1265826;
int _1265828;
_1265828 = -1 + gid_x_1265778;
bool _1265829;
_1265829 = _1265772 <= _1265828;
if (_1265829) goto l1265830; else goto l1265937;
l1265937: ;
union variant_220130 _1265938;
_1265938.qs32 = _1265828;
struct_BoundaryMode_220129 _1265939;
_1265939.e0 = 0;
_1265939.e1 = _1265938;
pbh_upper_1265833 = _1265939;
goto l1265831;
l1265830: ;
union variant_220130 _1265919_4416;
_1265919_4416.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4418;
_1265920_4418.e0 = 1;
_1265920_4418.e1 = _1265919_4416;
pbh_upper_1265833 = _1265920_4418;
goto l1265831;
l1265831: ;
bh_upper_1265833 = pbh_upper_1265833;
union variant_220130 _1265837;
_1265837 = bh_upper_1265833.e1;
unsigned int _1265834;
_1265834 = bh_upper_1265833.e0;
bool _1265835;
_1265835 = _1265834 == 0;
if (_1265835) goto l1265836; else goto l1265932;
l1265932: ;
bool _1265933;
_1265933 = _1265834 == 1;
if (_1265933) goto l1265934; else goto l1265936;
l1265936: ;
// bottom: float r4_1265918_4426;
// bottom: p_1265846 = r4_1265918_4426;
goto l1265844;
l1265934: ;
float c_1265935;
c_1265935 = _1265837.pf32;
p_1265846 = c_1265935;
goto l1265844;
l1265836: ;
int x_1265838;
x_1265838 = _1265837.qs32;
int _1265839;
_1265839 = _1265798 + x_1265838;
float* idx_1265840;
idx_1265840 = _1003236_1265727 + _1265839;
_1265843 = __ldg(idx_1265840);
p_1265843 = _1265843;
l1265841: ;
_1265843 = p_1265843;
p_1265846 = _1265843;
goto l1265844;
l1265844: ;
_1265846 = p_1265846;
int _1265847;
_1265847 = 1 + gid_x_1265778;
bool _1265848;
_1265848 = _1265772 <= _1265847;
if (_1265848) goto l1265849; else goto l1265929;
l1265929: ;
union variant_220130 _1265930;
_1265930.qs32 = _1265847;
struct_BoundaryMode_220129 _1265931;
_1265931.e0 = 0;
_1265931.e1 = _1265930;
pbh_upper_1265852 = _1265931;
goto l1265850;
l1265849: ;
union variant_220130 _1265919_4431;
_1265919_4431.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4433;
_1265920_4433.e0 = 1;
_1265920_4433.e1 = _1265919_4431;
pbh_upper_1265852 = _1265920_4433;
goto l1265850;
l1265850: ;
bh_upper_1265852 = pbh_upper_1265852;
union variant_220130 _1265856;
_1265856 = bh_upper_1265852.e1;
unsigned int _1265853;
_1265853 = bh_upper_1265852.e0;
bool _1265854;
_1265854 = _1265853 == 0;
if (_1265854) goto l1265855; else goto l1265924;
l1265924: ;
bool _1265925;
_1265925 = _1265853 == 1;
if (_1265925) goto l1265926; else goto l1265928;
l1265928: ;
// bottom: float r4_1265918_4441;
// bottom: p_1265865 = r4_1265918_4441;
goto l1265863;
l1265926: ;
float c_1265927;
c_1265927 = _1265856.pf32;
p_1265865 = c_1265927;
goto l1265863;
l1265855: ;
int x_1265857;
x_1265857 = _1265856.qs32;
int _1265858;
_1265858 = _1265798 + x_1265857;
float* idx_1265859;
idx_1265859 = _1003236_1265727 + _1265858;
_1265862 = __ldg(idx_1265859);
p_1265862 = _1265862;
l1265860: ;
_1265862 = p_1265862;
p_1265865 = _1265862;
goto l1265863;
l1265863: ;
_1265865 = p_1265865;
if (_1265779) goto l1265866; else goto l1265921;
l1265921: ;
pbh_upper_1265869 = _1265923;
goto l1265867;
l1265866: ;
union variant_220130 _1265919_4442;
_1265919_4442.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4444;
_1265920_4444.e0 = 1;
_1265920_4444.e1 = _1265919_4442;
pbh_upper_1265869 = _1265920_4444;
goto l1265867;
l1265867: ;
bh_upper_1265869 = pbh_upper_1265869;
unsigned int _1265870;
_1265870 = bh_upper_1265869.e0;
bool _1265871;
_1265871 = _1265870 == 0;
union variant_220130 _1265876;
_1265876 = bh_upper_1265869.e1;
if (_1265871) goto l1265872; else goto l1265913;
l1265913: ;
bool _1265914;
_1265914 = _1265870 == 1;
if (_1265914) goto l1265915; else goto l1265917;
l1265917: ;
// bottom: float r4_1265918_4452;
// bottom: p_1265885 = r4_1265918_4452;
goto l1265883;
l1265915: ;
float c_1265916;
c_1265916 = _1265876.pf32;
p_1265885 = c_1265916;
goto l1265883;
l1265872: ;
int x_1265877;
x_1265877 = _1265876.qs32;
int _1265874;
_1265874 = 2 + gid_y_1265794;
int _1265875;
_1265875 = _1265874 * _1265797;
int _1265878;
_1265878 = _1265875 + x_1265877;
float* idx_1265879;
idx_1265879 = _1003236_1265727 + _1265878;
_1265882 = __ldg(idx_1265879);
p_1265882 = _1265882;
l1265880: ;
_1265882 = p_1265882;
p_1265885 = _1265882;
goto l1265883;
l1265883: ;
_1265885 = p_1265885;
int _1265886;
_1265886 = _1003240_1265731.e3;
float _1265909;
_1265909 = 2.500000e-01f * _1265885;
float _1265898;
_1265898 = _1265897;
int _1265887;
_1265887 = _1265795 * _1265886;
float _1265903;
_1265903 = 2.500000e-01f * _1265826;
float _1265891;
_1265891 = 2.000000e-01f * _1265808;
float _1265904;
_1265904 = 0.000000e+00f + _1265903;
float _1265907;
_1265907 = 2.500000e-01f * _1265865;
float _1265899;
_1265899 = 2.000000e-01f * _1265898;
int _1265888;
_1265888 = _1265887 + gid_x_1265778;
float _1265905;
_1265905 = 2.500000e-01f * _1265846;
float* idx_1265889;
idx_1265889 = _1003238_1265729 + _1265888;
float _1265900;
_1265900 = _1265891 + _1265899;
float _1265906;
_1265906 = _1265904 + _1265905;
float _1265908;
_1265908 = _1265906 + _1265907;
float _1265910;
_1265910 = _1265908 + _1265909;
float val_1265911;
val_1265911 = _1265900 + _1265910;
*idx_1265889 = val_1265911;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1007672(struct_Img_220118 _1007675_1287688, struct_Img_220118 _1007676_1287689, float* _1007677_1287690, struct_Img_220118 _1007678_1287691, float* _1007679_1287692, float* _1007680_1287693) {
int _1287696;
int p_1287696;
int _1287699;
int p_1287699;
int _1287702;
int p_1287702;
int _1287705;
int p_1287705;
int _1287708;
int p_1287708;
int _1287711;
int p_1287711;
int _1287714;
int p_1287714;
struct_BoundaryMode_220129 bh_upper_1287725;
struct_BoundaryMode_220129 pbh_upper_1287725;
float _1287740;
float p_1287740;
float _1287743;
float p_1287743;
struct_BoundaryMode_220129 bh_upper_1287747;
struct_BoundaryMode_220129 pbh_upper_1287747;
float _1287758;
float p_1287758;
float _1287761;
float p_1287761;
struct_BoundaryMode_220129 bh_upper_1287767;
struct_BoundaryMode_220129 pbh_upper_1287767;
float _1287777;
float p_1287777;
float _1287780;
float p_1287780;
struct_BoundaryMode_220129 bh_upper_1287786;
struct_BoundaryMode_220129 pbh_upper_1287786;
float _1287796;
float p_1287796;
float _1287799;
float p_1287799;
struct_BoundaryMode_220129 bh_upper_1287803;
struct_BoundaryMode_220129 pbh_upper_1287803;
float _1287815;
float p_1287815;
float _1287818;
float p_1287818;
_1287696 = threadIdx_x();
p_1287696 = _1287696;
l1287694: ;
_1287696 = p_1287696;
_1287699 = blockDim_x();
p_1287699 = _1287699;
l1287697: ;
_1287699 = p_1287699;
_1287702 = blockIdx_x();
p_1287702 = _1287702;
l1287700: ;
_1287702 = p_1287702;
_1287705 = threadIdx_y();
p_1287705 = _1287705;
l1287703: ;
_1287705 = p_1287705;
_1287708 = blockDim_y();
p_1287708 = _1287708;
l1287706: ;
_1287708 = p_1287708;
_1287711 = blockIdx_y();
p_1287711 = _1287711;
l1287709: ;
_1287711 = p_1287711;
_1287714 = blockDim_y();
p_1287714 = _1287714;
l1287712: ;
_1287714 = p_1287714;
int _1287715;
_1287715 = _1007676_1287689.e1;
int _1287716;
_1287716 = _1007675_1287688.e1;
int _1287717;
_1287717 = _1287716 - 128;
int _1287719;
_1287719 = _1287699 * _1287702;
int _1287718;
_1287718 = _1287717 + _1287696;
int gid_x_1287720;
gid_x_1287720 = _1287718 + _1287719;
union variant_220130 _1287848;
_1287848.qs32 = gid_x_1287720;
bool _1287721;
_1287721 = _1287715 <= gid_x_1287720;
struct_BoundaryMode_220129 _1287849;
_1287849.e0 = 0;
_1287849.e1 = _1287848;
if (_1287721) goto l1287722; else goto l1287878;
l1287878: ;
pbh_upper_1287725 = _1287849;
goto l1287723;
l1287722: ;
union variant_220130 _1265919_4468;
_1265919_4468.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4470;
_1265920_4470.e0 = 1;
_1265920_4470.e1 = _1265919_4468;
pbh_upper_1287725 = _1265920_4470;
goto l1287723;
l1287723: ;
bh_upper_1287725 = pbh_upper_1287725;
int _1287729;
_1287729 = _1287708 * _1287711;
int gid_y_1287730;
gid_y_1287730 = _1287705 + _1287729;
int _1287731;
_1287731 = 1 + gid_y_1287730;
int _1287732;
_1287732 = _1007676_1287689.e3;
unsigned int _1287726;
_1287726 = bh_upper_1287725.e0;
union variant_220130 _1287734;
_1287734 = bh_upper_1287725.e1;
int _1287733;
_1287733 = _1287731 * _1287732;
bool _1287727;
_1287727 = _1287726 == 0;
if (_1287727) goto l1287728; else goto l1287873;
l1287873: ;
bool _1287874;
_1287874 = _1287726 == 1;
if (_1287874) goto l1287875; else goto l1287877;
l1287877: ;
// bottom: float r4_1265918_4480;
// bottom: p_1287743 = r4_1265918_4480;
goto l1287741;
l1287875: ;
float c_1287876;
c_1287876 = _1287734.pf32;
p_1287743 = c_1287876;
goto l1287741;
l1287728: ;
int x_1287735;
x_1287735 = _1287734.qs32;
int _1287736;
_1287736 = _1287733 + x_1287735;
float* idx_1287737;
idx_1287737 = _1007677_1287690 + _1287736;
_1287740 = __ldg(idx_1287737);
p_1287740 = _1287740;
l1287738: ;
_1287740 = p_1287740;
p_1287743 = _1287740;
goto l1287741;
l1287741: ;
_1287743 = p_1287743;
int _1287824;
_1287824 = _1007678_1287691.e3;
int _1287825;
_1287825 = _1287731 * _1287824;
int _1287826;
_1287826 = _1287825 + gid_x_1287720;
float* idx_1287827;
idx_1287827 = _1007680_1287693 + _1287826;
float _1287828;
_1287828 = *idx_1287827;
if (_1287721) goto l1287744; else goto l1287872;
l1287872: ;
pbh_upper_1287747 = _1287849;
goto l1287745;
l1287744: ;
union variant_220130 _1265919_4482;
_1265919_4482.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4484;
_1265920_4484.e0 = 1;
_1265920_4484.e1 = _1265919_4482;
pbh_upper_1287747 = _1265920_4484;
goto l1287745;
l1287745: ;
bh_upper_1287747 = pbh_upper_1287747;
unsigned int _1287748;
_1287748 = bh_upper_1287747.e0;
bool _1287749;
_1287749 = _1287748 == 0;
union variant_220130 _1287752;
_1287752 = bh_upper_1287747.e1;
if (_1287749) goto l1287750; else goto l1287866;
l1287866: ;
bool _1287867;
_1287867 = _1287748 == 1;
if (_1287867) goto l1287868; else goto l1287870;
l1287870: ;
// bottom: float r4_1265918_4492;
// bottom: p_1287761 = r4_1265918_4492;
goto l1287759;
l1287868: ;
float c_1287869;
c_1287869 = _1287752.pf32;
p_1287761 = c_1287869;
goto l1287759;
l1287750: ;
int _1287751;
_1287751 = gid_y_1287730 * _1287732;
int x_1287753;
x_1287753 = _1287752.qs32;
int _1287754;
_1287754 = _1287751 + x_1287753;
float* idx_1287755;
idx_1287755 = _1007677_1287690 + _1287754;
_1287758 = __ldg(idx_1287755);
p_1287758 = _1287758;
l1287756: ;
_1287758 = p_1287758;
p_1287761 = _1287758;
goto l1287759;
l1287759: ;
_1287761 = p_1287761;
int _1287762;
_1287762 = -1 + gid_x_1287720;
bool _1287763;
_1287763 = _1287715 <= _1287762;
if (_1287763) goto l1287764; else goto l1287863;
l1287863: ;
union variant_220130 _1287864;
_1287864.qs32 = _1287762;
struct_BoundaryMode_220129 _1287865;
_1287865.e0 = 0;
_1287865.e1 = _1287864;
pbh_upper_1287767 = _1287865;
goto l1287765;
l1287764: ;
union variant_220130 _1265919_4497;
_1265919_4497.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4499;
_1265920_4499.e0 = 1;
_1265920_4499.e1 = _1265919_4497;
pbh_upper_1287767 = _1265920_4499;
goto l1287765;
l1287765: ;
bh_upper_1287767 = pbh_upper_1287767;
union variant_220130 _1287771;
_1287771 = bh_upper_1287767.e1;
unsigned int _1287768;
_1287768 = bh_upper_1287767.e0;
bool _1287769;
_1287769 = _1287768 == 0;
if (_1287769) goto l1287770; else goto l1287858;
l1287858: ;
bool _1287859;
_1287859 = _1287768 == 1;
if (_1287859) goto l1287860; else goto l1287862;
l1287862: ;
// bottom: float r4_1265918_4507;
// bottom: p_1287780 = r4_1265918_4507;
goto l1287778;
l1287860: ;
float c_1287861;
c_1287861 = _1287771.pf32;
p_1287780 = c_1287861;
goto l1287778;
l1287770: ;
int x_1287772;
x_1287772 = _1287771.qs32;
int _1287773;
_1287773 = _1287733 + x_1287772;
float* idx_1287774;
idx_1287774 = _1007677_1287690 + _1287773;
_1287777 = __ldg(idx_1287774);
p_1287777 = _1287777;
l1287775: ;
_1287777 = p_1287777;
p_1287780 = _1287777;
goto l1287778;
l1287778: ;
_1287780 = p_1287780;
int _1287781;
_1287781 = 1 + gid_x_1287720;
bool _1287782;
_1287782 = _1287715 <= _1287781;
if (_1287782) goto l1287783; else goto l1287855;
l1287855: ;
union variant_220130 _1287856;
_1287856.qs32 = _1287781;
struct_BoundaryMode_220129 _1287857;
_1287857.e0 = 0;
_1287857.e1 = _1287856;
pbh_upper_1287786 = _1287857;
goto l1287784;
l1287783: ;
union variant_220130 _1265919_4512;
_1265919_4512.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4514;
_1265920_4514.e0 = 1;
_1265920_4514.e1 = _1265919_4512;
pbh_upper_1287786 = _1265920_4514;
goto l1287784;
l1287784: ;
bh_upper_1287786 = pbh_upper_1287786;
unsigned int _1287787;
_1287787 = bh_upper_1287786.e0;
union variant_220130 _1287790;
_1287790 = bh_upper_1287786.e1;
bool _1287788;
_1287788 = _1287787 == 0;
if (_1287788) goto l1287789; else goto l1287850;
l1287850: ;
bool _1287851;
_1287851 = _1287787 == 1;
if (_1287851) goto l1287852; else goto l1287854;
l1287854: ;
// bottom: float r4_1265918_4522;
// bottom: p_1287799 = r4_1265918_4522;
goto l1287797;
l1287852: ;
float c_1287853;
c_1287853 = _1287790.pf32;
p_1287799 = c_1287853;
goto l1287797;
l1287789: ;
int x_1287791;
x_1287791 = _1287790.qs32;
int _1287792;
_1287792 = _1287733 + x_1287791;
float* idx_1287793;
idx_1287793 = _1007677_1287690 + _1287792;
_1287796 = __ldg(idx_1287793);
p_1287796 = _1287796;
l1287794: ;
_1287796 = p_1287796;
p_1287799 = _1287796;
goto l1287797;
l1287797: ;
_1287799 = p_1287799;
if (_1287721) goto l1287800; else goto l1287847;
l1287847: ;
pbh_upper_1287803 = _1287849;
goto l1287801;
l1287800: ;
union variant_220130 _1265919_4523;
_1265919_4523.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4525;
_1265920_4525.e0 = 1;
_1265920_4525.e1 = _1265919_4523;
pbh_upper_1287803 = _1265920_4525;
goto l1287801;
l1287801: ;
bh_upper_1287803 = pbh_upper_1287803;
unsigned int _1287804;
_1287804 = bh_upper_1287803.e0;
union variant_220130 _1287809;
_1287809 = bh_upper_1287803.e1;
bool _1287805;
_1287805 = _1287804 == 0;
if (_1287805) goto l1287806; else goto l1287842;
l1287842: ;
bool _1287843;
_1287843 = _1287804 == 1;
if (_1287843) goto l1287844; else goto l1287846;
l1287846: ;
// bottom: float r4_1265918_4533;
// bottom: p_1287818 = r4_1265918_4533;
goto l1287816;
l1287844: ;
float c_1287845;
c_1287845 = _1287809.pf32;
p_1287818 = c_1287845;
goto l1287816;
l1287806: ;
int x_1287810;
x_1287810 = _1287809.qs32;
int _1287807;
_1287807 = 2 + gid_y_1287730;
int _1287808;
_1287808 = _1287807 * _1287732;
int _1287811;
_1287811 = _1287808 + x_1287810;
float* idx_1287812;
idx_1287812 = _1007677_1287690 + _1287811;
_1287815 = __ldg(idx_1287812);
p_1287815 = _1287815;
l1287813: ;
_1287815 = p_1287815;
p_1287818 = _1287815;
goto l1287816;
l1287816: ;
_1287818 = p_1287818;
float _1287823;
_1287823 = 2.000000e-01f * _1287743;
float _1287838;
_1287838 = 2.500000e-01f * _1287818;
float _1287834;
_1287834 = 2.500000e-01f * _1287780;
int _1287819;
_1287819 = _1007675_1287688.e3;
float _1287832;
_1287832 = 2.500000e-01f * _1287761;
int _1287820;
_1287820 = _1287731 * _1287819;
float _1287836;
_1287836 = 2.500000e-01f * _1287799;
float _1287833;
_1287833 = 0.000000e+00f + _1287832;
int _1287821;
_1287821 = _1287820 + gid_x_1287720;
float _1287829;
_1287829 = _1287828;
float _1287830;
_1287830 = 2.000000e-01f * _1287829;
float _1287831;
_1287831 = _1287823 + _1287830;
float _1287835;
_1287835 = _1287833 + _1287834;
float _1287837;
_1287837 = _1287835 + _1287836;
float* idx_1287822;
idx_1287822 = _1007679_1287692 + _1287821;
float _1287839;
_1287839 = _1287837 + _1287838;
float val_1287840;
val_1287840 = _1287831 + _1287839;
*idx_1287822 = val_1287840;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1029152(struct_Img_220118 _1029155_1280284, float* _1029156_1280285, float* _1029157_1280286, struct_Img_220118 _1029158_1280287, struct_Img_220118 _1029159_1280288, float* _1029160_1280289) {
int _1280292;
int p_1280292;
int _1280295;
int p_1280295;
int _1280298;
int p_1280298;
int _1280301;
int p_1280301;
int _1280304;
int p_1280304;
int _1280307;
int p_1280307;
int _1280310;
int p_1280310;
struct_BoundaryMode_220129 bh_lower_1280317;
struct_BoundaryMode_220129 pbh_lower_1280317;
float _1280332;
float p_1280332;
float _1280335;
float p_1280335;
struct_BoundaryMode_220129 bh_lower_1280339;
struct_BoundaryMode_220129 pbh_lower_1280339;
float _1280350;
float p_1280350;
float _1280353;
float p_1280353;
struct_BoundaryMode_220129 bh_lower_1280359;
struct_BoundaryMode_220129 pbh_lower_1280359;
float _1280369;
float p_1280369;
float _1280372;
float p_1280372;
struct_BoundaryMode_220129 bh_lower_1280378;
struct_BoundaryMode_220129 pbh_lower_1280378;
float _1280388;
float p_1280388;
float _1280391;
float p_1280391;
struct_BoundaryMode_220129 bh_lower_1280395;
struct_BoundaryMode_220129 pbh_lower_1280395;
float _1280407;
float p_1280407;
float _1280410;
float p_1280410;
_1280292 = threadIdx_x();
p_1280292 = _1280292;
l1280290: ;
_1280292 = p_1280292;
_1280295 = blockDim_x();
p_1280295 = _1280295;
l1280293: ;
_1280295 = p_1280295;
_1280298 = blockIdx_x();
p_1280298 = _1280298;
l1280296: ;
_1280298 = p_1280298;
_1280301 = threadIdx_y();
p_1280301 = _1280301;
l1280299: ;
_1280301 = p_1280301;
_1280304 = blockDim_y();
p_1280304 = _1280304;
l1280302: ;
_1280304 = p_1280304;
_1280307 = blockIdx_y();
p_1280307 = _1280307;
l1280305: ;
_1280307 = p_1280307;
_1280310 = blockDim_y();
p_1280310 = _1280310;
l1280308: ;
_1280310 = p_1280310;
int _1280311;
_1280311 = _1280295 * _1280298;
int gid_x_1280312;
gid_x_1280312 = _1280292 + _1280311;
bool _1280313;
_1280313 = gid_x_1280312 < 0;
union variant_220130 _1280440;
_1280440.qs32 = gid_x_1280312;
struct_BoundaryMode_220129 _1280441;
_1280441.e0 = 0;
_1280441.e1 = _1280440;
if (_1280313) goto l1280314; else goto l1280470;
l1280470: ;
pbh_lower_1280317 = _1280441;
goto l1280315;
l1280314: ;
union variant_220130 _1265919_4547;
_1265919_4547.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4549;
_1265920_4549.e0 = 1;
_1265920_4549.e1 = _1265919_4547;
pbh_lower_1280317 = _1265920_4549;
goto l1280315;
l1280315: ;
bh_lower_1280317 = pbh_lower_1280317;
union variant_220130 _1280326;
_1280326 = bh_lower_1280317.e1;
int _1280321;
_1280321 = _1280304 * _1280307;
int gid_y_1280322;
gid_y_1280322 = _1280301 + _1280321;
int _1280324;
_1280324 = _1029158_1280287.e3;
unsigned int _1280318;
_1280318 = bh_lower_1280317.e0;
int _1280323;
_1280323 = 1 + gid_y_1280322;
int _1280325;
_1280325 = _1280323 * _1280324;
bool _1280319;
_1280319 = _1280318 == 0;
if (_1280319) goto l1280320; else goto l1280465;
l1280465: ;
bool _1280466;
_1280466 = _1280318 == 1;
if (_1280466) goto l1280467; else goto l1280469;
l1280469: ;
// bottom: float r4_1265918_4559;
// bottom: p_1280335 = r4_1265918_4559;
goto l1280333;
l1280467: ;
float c_1280468;
c_1280468 = _1280326.pf32;
p_1280335 = c_1280468;
goto l1280333;
l1280320: ;
int x_1280327;
x_1280327 = _1280326.qs32;
int _1280328;
_1280328 = _1280325 + x_1280327;
float* idx_1280329;
idx_1280329 = _1029157_1280286 + _1280328;
_1280332 = __ldg(idx_1280329);
p_1280332 = _1280332;
l1280330: ;
_1280332 = p_1280332;
p_1280335 = _1280332;
goto l1280333;
l1280333: ;
_1280335 = p_1280335;
int _1280416;
_1280416 = _1029155_1280284.e3;
int _1280417;
_1280417 = _1280323 * _1280416;
int _1280418;
_1280418 = _1280417 + gid_x_1280312;
float* idx_1280419;
idx_1280419 = _1029160_1280289 + _1280418;
float _1280420;
_1280420 = *idx_1280419;
if (_1280313) goto l1280336; else goto l1280464;
l1280464: ;
pbh_lower_1280339 = _1280441;
goto l1280337;
l1280336: ;
union variant_220130 _1265919_4561;
_1265919_4561.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4563;
_1265920_4563.e0 = 1;
_1265920_4563.e1 = _1265919_4561;
pbh_lower_1280339 = _1265920_4563;
goto l1280337;
l1280337: ;
bh_lower_1280339 = pbh_lower_1280339;
union variant_220130 _1280344;
_1280344 = bh_lower_1280339.e1;
unsigned int _1280340;
_1280340 = bh_lower_1280339.e0;
bool _1280341;
_1280341 = _1280340 == 0;
if (_1280341) goto l1280342; else goto l1280458;
l1280458: ;
bool _1280459;
_1280459 = _1280340 == 1;
if (_1280459) goto l1280460; else goto l1280462;
l1280462: ;
// bottom: float r4_1265918_4571;
// bottom: p_1280353 = r4_1265918_4571;
goto l1280351;
l1280460: ;
float c_1280461;
c_1280461 = _1280344.pf32;
p_1280353 = c_1280461;
goto l1280351;
l1280342: ;
int _1280343;
_1280343 = gid_y_1280322 * _1280324;
int x_1280345;
x_1280345 = _1280344.qs32;
int _1280346;
_1280346 = _1280343 + x_1280345;
float* idx_1280347;
idx_1280347 = _1029157_1280286 + _1280346;
_1280350 = __ldg(idx_1280347);
p_1280350 = _1280350;
l1280348: ;
_1280350 = p_1280350;
p_1280353 = _1280350;
goto l1280351;
l1280351: ;
_1280353 = p_1280353;
int _1280354;
_1280354 = -1 + gid_x_1280312;
bool _1280355;
_1280355 = _1280354 < 0;
if (_1280355) goto l1280356; else goto l1280455;
l1280455: ;
union variant_220130 _1280456;
_1280456.qs32 = _1280354;
struct_BoundaryMode_220129 _1280457;
_1280457.e0 = 0;
_1280457.e1 = _1280456;
pbh_lower_1280359 = _1280457;
goto l1280357;
l1280356: ;
union variant_220130 _1265919_4577;
_1265919_4577.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4579;
_1265920_4579.e0 = 1;
_1265920_4579.e1 = _1265919_4577;
pbh_lower_1280359 = _1265920_4579;
goto l1280357;
l1280357: ;
bh_lower_1280359 = pbh_lower_1280359;
union variant_220130 _1280363;
_1280363 = bh_lower_1280359.e1;
unsigned int _1280360;
_1280360 = bh_lower_1280359.e0;
bool _1280361;
_1280361 = _1280360 == 0;
if (_1280361) goto l1280362; else goto l1280450;
l1280450: ;
bool _1280451;
_1280451 = _1280360 == 1;
if (_1280451) goto l1280452; else goto l1280454;
l1280454: ;
// bottom: float r4_1265918_4587;
// bottom: p_1280372 = r4_1265918_4587;
goto l1280370;
l1280452: ;
float c_1280453;
c_1280453 = _1280363.pf32;
p_1280372 = c_1280453;
goto l1280370;
l1280362: ;
int x_1280364;
x_1280364 = _1280363.qs32;
int _1280365;
_1280365 = _1280325 + x_1280364;
float* idx_1280366;
idx_1280366 = _1029157_1280286 + _1280365;
_1280369 = __ldg(idx_1280366);
p_1280369 = _1280369;
l1280367: ;
_1280369 = p_1280369;
p_1280372 = _1280369;
goto l1280370;
l1280370: ;
_1280372 = p_1280372;
int _1280373;
_1280373 = 1 + gid_x_1280312;
bool _1280374;
_1280374 = _1280373 < 0;
if (_1280374) goto l1280375; else goto l1280447;
l1280447: ;
union variant_220130 _1280448;
_1280448.qs32 = _1280373;
struct_BoundaryMode_220129 _1280449;
_1280449.e0 = 0;
_1280449.e1 = _1280448;
pbh_lower_1280378 = _1280449;
goto l1280376;
l1280375: ;
union variant_220130 _1265919_4593;
_1265919_4593.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4595;
_1265920_4595.e0 = 1;
_1265920_4595.e1 = _1265919_4593;
pbh_lower_1280378 = _1265920_4595;
goto l1280376;
l1280376: ;
bh_lower_1280378 = pbh_lower_1280378;
union variant_220130 _1280382;
_1280382 = bh_lower_1280378.e1;
unsigned int _1280379;
_1280379 = bh_lower_1280378.e0;
bool _1280380;
_1280380 = _1280379 == 0;
if (_1280380) goto l1280381; else goto l1280442;
l1280442: ;
bool _1280443;
_1280443 = _1280379 == 1;
if (_1280443) goto l1280444; else goto l1280446;
l1280446: ;
// bottom: float r4_1265918_4603;
// bottom: p_1280391 = r4_1265918_4603;
goto l1280389;
l1280444: ;
float c_1280445;
c_1280445 = _1280382.pf32;
p_1280391 = c_1280445;
goto l1280389;
l1280381: ;
int x_1280383;
x_1280383 = _1280382.qs32;
int _1280384;
_1280384 = _1280325 + x_1280383;
float* idx_1280385;
idx_1280385 = _1029157_1280286 + _1280384;
_1280388 = __ldg(idx_1280385);
p_1280388 = _1280388;
l1280386: ;
_1280388 = p_1280388;
p_1280391 = _1280388;
goto l1280389;
l1280389: ;
_1280391 = p_1280391;
if (_1280313) goto l1280392; else goto l1280439;
l1280439: ;
pbh_lower_1280395 = _1280441;
goto l1280393;
l1280392: ;
union variant_220130 _1265919_4604;
_1265919_4604.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4606;
_1265920_4606.e0 = 1;
_1265920_4606.e1 = _1265919_4604;
pbh_lower_1280395 = _1265920_4606;
goto l1280393;
l1280393: ;
bh_lower_1280395 = pbh_lower_1280395;
unsigned int _1280396;
_1280396 = bh_lower_1280395.e0;
union variant_220130 _1280401;
_1280401 = bh_lower_1280395.e1;
bool _1280397;
_1280397 = _1280396 == 0;
if (_1280397) goto l1280398; else goto l1280434;
l1280434: ;
bool _1280435;
_1280435 = _1280396 == 1;
if (_1280435) goto l1280436; else goto l1280438;
l1280438: ;
// bottom: float r4_1265918_4614;
// bottom: p_1280410 = r4_1265918_4614;
goto l1280408;
l1280436: ;
float c_1280437;
c_1280437 = _1280401.pf32;
p_1280410 = c_1280437;
goto l1280408;
l1280398: ;
int x_1280402;
x_1280402 = _1280401.qs32;
int _1280399;
_1280399 = 2 + gid_y_1280322;
int _1280400;
_1280400 = _1280399 * _1280324;
int _1280403;
_1280403 = _1280400 + x_1280402;
float* idx_1280404;
idx_1280404 = _1029157_1280286 + _1280403;
_1280407 = __ldg(idx_1280404);
p_1280407 = _1280407;
l1280405: ;
_1280407 = p_1280407;
p_1280410 = _1280407;
goto l1280408;
l1280408: ;
_1280410 = p_1280410;
float _1280430;
_1280430 = 2.500000e-01f * _1280410;
int _1280411;
_1280411 = _1029159_1280288.e3;
float _1280426;
_1280426 = 2.500000e-01f * _1280372;
float _1280428;
_1280428 = 2.500000e-01f * _1280391;
float _1280424;
_1280424 = 2.500000e-01f * _1280353;
float _1280421;
_1280421 = _1280420;
float _1280415;
_1280415 = 2.000000e-01f * _1280335;
int _1280412;
_1280412 = _1280323 * _1280411;
float _1280425;
_1280425 = 0.000000e+00f + _1280424;
float _1280422;
_1280422 = 2.000000e-01f * _1280421;
float _1280423;
_1280423 = _1280415 + _1280422;
int _1280413;
_1280413 = _1280412 + gid_x_1280312;
float _1280427;
_1280427 = _1280425 + _1280426;
float* idx_1280414;
idx_1280414 = _1029156_1280285 + _1280413;
float _1280429;
_1280429 = _1280427 + _1280428;
float _1280431;
_1280431 = _1280429 + _1280430;
float val_1280432;
val_1280432 = _1280423 + _1280431;
*idx_1280414 = val_1280432;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1035062(float* _1035065_1269249, struct_Img_220118 _1035066_1269250, float* _1035067_1269251, struct_Img_220118 _1035068_1269252, struct_Img_220118 _1035069_1269253, float* _1035070_1269254) {
int _1269257;
int p_1269257;
int _1269260;
int p_1269260;
int _1269263;
int p_1269263;
int _1269266;
int p_1269266;
int _1269269;
int p_1269269;
int _1269272;
int p_1269272;
int _1269275;
int p_1269275;
float _1269288;
float p_1269288;
float _1269302;
float p_1269302;
float _1269307;
float p_1269307;
float _1269312;
float p_1269312;
float _1269320;
float p_1269320;
_1269257 = threadIdx_x();
p_1269257 = _1269257;
l1269255: ;
_1269257 = p_1269257;
_1269260 = blockDim_x();
p_1269260 = _1269260;
l1269258: ;
_1269260 = p_1269260;
_1269263 = blockIdx_x();
p_1269263 = _1269263;
l1269261: ;
_1269263 = p_1269263;
_1269266 = threadIdx_y();
p_1269266 = _1269266;
l1269264: ;
_1269266 = p_1269266;
_1269269 = blockDim_y();
p_1269269 = _1269269;
l1269267: ;
_1269269 = p_1269269;
_1269272 = blockIdx_y();
p_1269272 = _1269272;
l1269270: ;
_1269272 = p_1269272;
_1269275 = blockDim_y();
p_1269275 = _1269275;
l1269273: ;
_1269275 = p_1269275;
int _1269281;
_1269281 = _1269260 * _1269263;
int _1269279;
_1269279 = _1035068_1269252.e3;
int _1269276;
_1269276 = _1269269 * _1269272;
int gid_x_1269282;
gid_x_1269282 = _1269257 + _1269281;
int gid_y_1269277;
gid_y_1269277 = _1269266 + _1269276;
int _1269278;
_1269278 = 1 + gid_y_1269277;
int _1269280;
_1269280 = _1269278 * _1269279;
int _1269283;
_1269283 = _1269280 + gid_x_1269282;
int _1269284;
_1269284 = 128 + _1269283;
float* idx_1269285;
idx_1269285 = _1035067_1269251 + _1269284;
_1269288 = __ldg(idx_1269285);
p_1269288 = _1269288;
l1269286: ;
_1269288 = p_1269288;
int _1269289;
_1269289 = _1035066_1269250.e3;
int _1269290;
_1269290 = _1269278 * _1269289;
int _1269296;
_1269296 = gid_y_1269277 * _1269279;
int _1269297;
_1269297 = _1269296 + gid_x_1269282;
int _1269291;
_1269291 = _1269290 + gid_x_1269282;
int _1269298;
_1269298 = 128 + _1269297;
int _1269292;
_1269292 = 128 + _1269291;
float* idx_1269299;
idx_1269299 = _1035067_1269251 + _1269298;
float* idx_1269293;
idx_1269293 = _1035070_1269254 + _1269292;
float _1269294;
_1269294 = *idx_1269293;
_1269302 = __ldg(idx_1269299);
p_1269302 = _1269302;
l1269300: ;
_1269302 = p_1269302;
int _1269303;
_1269303 = 127 + _1269283;
float* idx_1269304;
idx_1269304 = _1035067_1269251 + _1269303;
_1269307 = __ldg(idx_1269304);
p_1269307 = _1269307;
l1269305: ;
_1269307 = p_1269307;
int _1269308;
_1269308 = 129 + _1269283;
float* idx_1269309;
idx_1269309 = _1035067_1269251 + _1269308;
_1269312 = __ldg(idx_1269309);
p_1269312 = _1269312;
l1269310: ;
_1269312 = p_1269312;
int _1269313;
_1269313 = 2 + gid_y_1269277;
int _1269314;
_1269314 = _1269313 * _1269279;
int _1269315;
_1269315 = _1269314 + gid_x_1269282;
int _1269316;
_1269316 = 128 + _1269315;
float* idx_1269317;
idx_1269317 = _1035067_1269251 + _1269316;
_1269320 = __ldg(idx_1269317);
p_1269320 = _1269320;
l1269318: ;
_1269320 = p_1269320;
float _1269334;
_1269334 = 2.500000e-01f * _1269312;
int _1269321;
_1269321 = _1035069_1269253.e3;
float _1269327;
_1269327 = _1269294;
float _1269326;
_1269326 = 2.000000e-01f * _1269288;
float _1269336;
_1269336 = 2.500000e-01f * _1269320;
float _1269330;
_1269330 = 2.500000e-01f * _1269302;
int _1269322;
_1269322 = _1269278 * _1269321;
float _1269332;
_1269332 = 2.500000e-01f * _1269307;
int _1269323;
_1269323 = _1269322 + gid_x_1269282;
float _1269331;
_1269331 = 0.000000e+00f + _1269330;
float _1269328;
_1269328 = 2.000000e-01f * _1269327;
float _1269329;
_1269329 = _1269326 + _1269328;
float _1269333;
_1269333 = _1269331 + _1269332;
int _1269324;
_1269324 = 128 + _1269323;
float _1269335;
_1269335 = _1269333 + _1269334;
float* idx_1269325;
idx_1269325 = _1035065_1269249 + _1269324;
float _1269337;
_1269337 = _1269335 + _1269336;
float val_1269338;
val_1269338 = _1269329 + _1269337;
*idx_1269325 = val_1269338;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1010617(struct_Img_220118 _1010620_1272936, struct_Img_220118 _1010621_1272937, float* _1010622_1272938, struct_Img_220118 _1010623_1272939, float* _1010624_1272940, float* _1010625_1272941) {
int _1272944;
int p_1272944;
int _1272947;
int p_1272947;
int _1272950;
int p_1272950;
int _1272953;
int p_1272953;
int _1272956;
int p_1272956;
int _1272959;
int p_1272959;
int _1272962;
int p_1272962;
struct_BoundaryMode_220129 bh_lower_1272969;
struct_BoundaryMode_220129 pbh_lower_1272969;
struct_BoundaryMode_220129 bh_upper_1272980;
struct_BoundaryMode_220129 pbh_upper_1272980;
float _1272997;
float p_1272997;
float _1273000;
float p_1273000;
struct_BoundaryMode_220129 bh_lower_1273004;
struct_BoundaryMode_220129 pbh_lower_1273004;
struct_BoundaryMode_220129 bh_upper_1273010;
struct_BoundaryMode_220129 pbh_upper_1273010;
float _1273026;
float p_1273026;
float _1273029;
float p_1273029;
struct_BoundaryMode_220129 bh_lower_1273035;
struct_BoundaryMode_220129 pbh_lower_1273035;
struct_BoundaryMode_220129 bh_upper_1273039;
struct_BoundaryMode_220129 pbh_upper_1273039;
float _1273055;
float p_1273055;
float _1273058;
float p_1273058;
struct_BoundaryMode_220129 bh_lower_1273064;
struct_BoundaryMode_220129 pbh_lower_1273064;
struct_BoundaryMode_220129 bh_upper_1273068;
struct_BoundaryMode_220129 pbh_upper_1273068;
float _1273084;
float p_1273084;
float _1273087;
float p_1273087;
struct_BoundaryMode_220129 bh_lower_1273091;
struct_BoundaryMode_220129 pbh_lower_1273091;
struct_BoundaryMode_220129 bh_upper_1273097;
struct_BoundaryMode_220129 pbh_upper_1273097;
float _1273113;
float p_1273113;
float _1273116;
float p_1273116;
_1272944 = threadIdx_x();
p_1272944 = _1272944;
l1272942: ;
_1272944 = p_1272944;
_1272947 = blockDim_x();
p_1272947 = _1272947;
l1272945: ;
_1272947 = p_1272947;
_1272950 = blockIdx_x();
p_1272950 = _1272950;
l1272948: ;
_1272950 = p_1272950;
_1272953 = threadIdx_y();
p_1272953 = _1272953;
l1272951: ;
_1272953 = p_1272953;
_1272956 = blockDim_y();
p_1272956 = _1272956;
l1272954: ;
_1272956 = p_1272956;
_1272959 = blockIdx_y();
p_1272959 = _1272959;
l1272957: ;
_1272959 = p_1272959;
_1272962 = blockDim_y();
p_1272962 = _1272962;
l1272960: ;
_1272962 = p_1272962;
int _1272963;
_1272963 = _1272947 * _1272950;
int gid_x_1272964;
gid_x_1272964 = _1272944 + _1272963;
bool _1272965;
_1272965 = gid_x_1272964 < 0;
union variant_220130 _1273153;
_1273153.qs32 = gid_x_1272964;
struct_BoundaryMode_220129 _1273154;
_1273154.e0 = 0;
_1273154.e1 = _1273153;
if (_1272965) goto l1272966; else goto l1273207;
l1273207: ;
pbh_lower_1272969 = _1273154;
goto l1272967;
l1272966: ;
union variant_220130 _1265919_4647;
_1265919_4647.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4649;
_1265920_4649.e0 = 1;
_1265920_4649.e1 = _1265919_4647;
pbh_lower_1272969 = _1265920_4649;
goto l1272967;
l1272967: ;
bh_lower_1272969 = pbh_lower_1272969;
int _1272970;
_1272970 = _1010620_1272936.e2;
int _1272971;
_1272971 = _1010623_1272939.e2;
int _1272974;
_1272974 = _1272956 * _1272959;
int _1272972;
_1272972 = _1272971 - 1;
int _1272973;
_1272973 = _1272972 + _1272953;
int gid_y_1272975;
gid_y_1272975 = _1272973 + _1272974;
bool _1272976;
_1272976 = _1272970 <= gid_y_1272975;
union variant_220130 _1273165;
_1273165.qs32 = gid_y_1272975;
struct_BoundaryMode_220129 _1273166;
_1273166.e0 = 0;
_1273166.e1 = _1273165;
if (_1272976) goto l1272977; else goto l1273206;
l1273206: ;
pbh_upper_1272980 = _1273166;
goto l1272978;
l1272977: ;
union variant_220130 _1265919_4659;
_1265919_4659.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4661;
_1265920_4661.e0 = 1;
_1265920_4661.e1 = _1265919_4659;
pbh_upper_1272980 = _1265920_4661;
goto l1272978;
l1272978: ;
bh_upper_1272980 = pbh_upper_1272980;
unsigned int _1272981;
_1272981 = bh_lower_1272969.e0;
unsigned int _1272983;
_1272983 = bh_upper_1272980.e0;
int _1272989;
_1272989 = _1010620_1272936.e3;
union variant_220130 _1272991;
_1272991 = bh_lower_1272969.e1;
bool _1272982;
_1272982 = _1272981 == 0;
union variant_220130 _1272987;
_1272987 = bh_upper_1272980.e1;
bool _1272984;
_1272984 = _1272983 == 0;
bool _1272985;
_1272985 = _1272982 & _1272984;
if (_1272985) goto l1272986; else goto l1273197;
l1273197: ;
bool _1273198;
_1273198 = _1272981 == 1;
if (_1273198) goto l1273199; else goto l1273201;
l1273201: ;
bool _1273202;
_1273202 = _1272983 == 1;
if (_1273202) goto l1273203; else goto l1273205;
l1273205: ;
// bottom: float r4_1265918_4674;
// bottom: p_1273000 = r4_1265918_4674;
goto l1272998;
l1273203: ;
float c_1273204;
c_1273204 = _1272987.pf32;
p_1273000 = c_1273204;
goto l1272998;
l1273199: ;
float c_1273200;
c_1273200 = _1272991.pf32;
p_1273000 = c_1273200;
goto l1272998;
l1272986: ;
int x_1272992;
x_1272992 = _1272991.qs32;
int y_1272988;
y_1272988 = _1272987.qs32;
int _1272990;
_1272990 = y_1272988 * _1272989;
int _1272993;
_1272993 = _1272990 + x_1272992;
float* idx_1272994;
idx_1272994 = _1010624_1272940 + _1272993;
_1272997 = __ldg(idx_1272994);
p_1272997 = _1272997;
l1272995: ;
_1272997 = p_1272997;
p_1273000 = _1272997;
goto l1272998;
l1272998: ;
_1273000 = p_1273000;
int _1273122;
_1273122 = _1010621_1272937.e3;
int _1273123;
_1273123 = gid_y_1272975 * _1273122;
int _1273124;
_1273124 = _1273123 + gid_x_1272964;
float* idx_1273125;
idx_1273125 = _1010625_1272941 + _1273124;
float _1273126;
_1273126 = *idx_1273125;
if (_1272965) goto l1273001; else goto l1273196;
l1273196: ;
pbh_lower_1273004 = _1273154;
goto l1273002;
l1273001: ;
union variant_220130 _1265919_4676;
_1265919_4676.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4678;
_1265920_4678.e0 = 1;
_1265920_4678.e1 = _1265919_4676;
pbh_lower_1273004 = _1265920_4678;
goto l1273002;
l1273002: ;
bh_lower_1273004 = pbh_lower_1273004;
int _1273005;
_1273005 = -1 + gid_y_1272975;
bool _1273006;
_1273006 = _1272970 <= _1273005;
if (_1273006) goto l1273007; else goto l1273192;
l1273192: ;
union variant_220130 _1273193;
_1273193.qs32 = _1273005;
struct_BoundaryMode_220129 _1273194;
_1273194.e0 = 0;
_1273194.e1 = _1273193;
pbh_upper_1273010 = _1273194;
goto l1273008;
l1273007: ;
union variant_220130 _1265919_4686;
_1265919_4686.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4688;
_1265920_4688.e0 = 1;
_1265920_4688.e1 = _1265919_4686;
pbh_upper_1273010 = _1265920_4688;
goto l1273008;
l1273008: ;
bh_upper_1273010 = pbh_upper_1273010;
union variant_220130 _1273020;
_1273020 = bh_lower_1273004.e1;
unsigned int _1273011;
_1273011 = bh_lower_1273004.e0;
bool _1273012;
_1273012 = _1273011 == 0;
union variant_220130 _1273017;
_1273017 = bh_upper_1273010.e1;
unsigned int _1273013;
_1273013 = bh_upper_1273010.e0;
bool _1273014;
_1273014 = _1273013 == 0;
bool _1273015;
_1273015 = _1273012 & _1273014;
if (_1273015) goto l1273016; else goto l1273183;
l1273183: ;
bool _1273184;
_1273184 = _1273011 == 1;
if (_1273184) goto l1273185; else goto l1273187;
l1273187: ;
bool _1273188;
_1273188 = _1273013 == 1;
if (_1273188) goto l1273189; else goto l1273191;
l1273191: ;
// bottom: float r4_1265918_4700;
// bottom: p_1273029 = r4_1265918_4700;
goto l1273027;
l1273189: ;
float c_1273190;
c_1273190 = _1273017.pf32;
p_1273029 = c_1273190;
goto l1273027;
l1273185: ;
float c_1273186;
c_1273186 = _1273020.pf32;
p_1273029 = c_1273186;
goto l1273027;
l1273016: ;
int y_1273018;
y_1273018 = _1273017.qs32;
int x_1273021;
x_1273021 = _1273020.qs32;
int _1273019;
_1273019 = y_1273018 * _1272989;
int _1273022;
_1273022 = _1273019 + x_1273021;
float* idx_1273023;
idx_1273023 = _1010624_1272940 + _1273022;
_1273026 = __ldg(idx_1273023);
p_1273026 = _1273026;
l1273024: ;
_1273026 = p_1273026;
p_1273029 = _1273026;
goto l1273027;
l1273027: ;
_1273029 = p_1273029;
int _1273030;
_1273030 = -1 + gid_x_1272964;
bool _1273031;
_1273031 = _1273030 < 0;
if (_1273031) goto l1273032; else goto l1273180;
l1273180: ;
union variant_220130 _1273181;
_1273181.qs32 = _1273030;
struct_BoundaryMode_220129 _1273182;
_1273182.e0 = 0;
_1273182.e1 = _1273181;
pbh_lower_1273035 = _1273182;
goto l1273033;
l1273032: ;
union variant_220130 _1265919_4706;
_1265919_4706.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4708;
_1265920_4708.e0 = 1;
_1265920_4708.e1 = _1265919_4706;
pbh_lower_1273035 = _1265920_4708;
goto l1273033;
l1273033: ;
bh_lower_1273035 = pbh_lower_1273035;
if (_1272976) goto l1273036; else goto l1273179;
l1273179: ;
pbh_upper_1273039 = _1273166;
goto l1273037;
l1273036: ;
union variant_220130 _1265919_4712;
_1265919_4712.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4714;
_1265920_4714.e0 = 1;
_1265920_4714.e1 = _1265919_4712;
pbh_upper_1273039 = _1265920_4714;
goto l1273037;
l1273037: ;
bh_upper_1273039 = pbh_upper_1273039;
union variant_220130 _1273049;
_1273049 = bh_lower_1273035.e1;
unsigned int _1273042;
_1273042 = bh_upper_1273039.e0;
unsigned int _1273040;
_1273040 = bh_lower_1273035.e0;
bool _1273041;
_1273041 = _1273040 == 0;
union variant_220130 _1273046;
_1273046 = bh_upper_1273039.e1;
bool _1273043;
_1273043 = _1273042 == 0;
bool _1273044;
_1273044 = _1273041 & _1273043;
if (_1273044) goto l1273045; else goto l1273170;
l1273170: ;
bool _1273171;
_1273171 = _1273040 == 1;
if (_1273171) goto l1273172; else goto l1273174;
l1273174: ;
bool _1273175;
_1273175 = _1273042 == 1;
if (_1273175) goto l1273176; else goto l1273178;
l1273178: ;
// bottom: float r4_1265918_4726;
// bottom: p_1273058 = r4_1265918_4726;
goto l1273056;
l1273176: ;
float c_1273177;
c_1273177 = _1273046.pf32;
p_1273058 = c_1273177;
goto l1273056;
l1273172: ;
float c_1273173;
c_1273173 = _1273049.pf32;
p_1273058 = c_1273173;
goto l1273056;
l1273045: ;
int y_1273047;
y_1273047 = _1273046.qs32;
int _1273048;
_1273048 = y_1273047 * _1272989;
int x_1273050;
x_1273050 = _1273049.qs32;
int _1273051;
_1273051 = _1273048 + x_1273050;
float* idx_1273052;
idx_1273052 = _1010624_1272940 + _1273051;
_1273055 = __ldg(idx_1273052);
p_1273055 = _1273055;
l1273053: ;
_1273055 = p_1273055;
p_1273058 = _1273055;
goto l1273056;
l1273056: ;
_1273058 = p_1273058;
int _1273059;
_1273059 = 1 + gid_x_1272964;
bool _1273060;
_1273060 = _1273059 < 0;
if (_1273060) goto l1273061; else goto l1273167;
l1273167: ;
union variant_220130 _1273168;
_1273168.qs32 = _1273059;
struct_BoundaryMode_220129 _1273169;
_1273169.e0 = 0;
_1273169.e1 = _1273168;
pbh_lower_1273064 = _1273169;
goto l1273062;
l1273061: ;
union variant_220130 _1265919_4732;
_1265919_4732.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4734;
_1265920_4734.e0 = 1;
_1265920_4734.e1 = _1265919_4732;
pbh_lower_1273064 = _1265920_4734;
goto l1273062;
l1273062: ;
bh_lower_1273064 = pbh_lower_1273064;
if (_1272976) goto l1273065; else goto l1273164;
l1273164: ;
pbh_upper_1273068 = _1273166;
goto l1273066;
l1273065: ;
union variant_220130 _1265919_4738;
_1265919_4738.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4740;
_1265920_4740.e0 = 1;
_1265920_4740.e1 = _1265919_4738;
pbh_upper_1273068 = _1265920_4740;
goto l1273066;
l1273066: ;
bh_upper_1273068 = pbh_upper_1273068;
unsigned int _1273069;
_1273069 = bh_lower_1273064.e0;
unsigned int _1273071;
_1273071 = bh_upper_1273068.e0;
union variant_220130 _1273078;
_1273078 = bh_lower_1273064.e1;
bool _1273072;
_1273072 = _1273071 == 0;
union variant_220130 _1273075;
_1273075 = bh_upper_1273068.e1;
bool _1273070;
_1273070 = _1273069 == 0;
bool _1273073;
_1273073 = _1273070 & _1273072;
if (_1273073) goto l1273074; else goto l1273155;
l1273155: ;
bool _1273156;
_1273156 = _1273069 == 1;
if (_1273156) goto l1273157; else goto l1273159;
l1273159: ;
bool _1273160;
_1273160 = _1273071 == 1;
if (_1273160) goto l1273161; else goto l1273163;
l1273163: ;
// bottom: float r4_1265918_4752;
// bottom: p_1273087 = r4_1265918_4752;
goto l1273085;
l1273161: ;
float c_1273162;
c_1273162 = _1273075.pf32;
p_1273087 = c_1273162;
goto l1273085;
l1273157: ;
float c_1273158;
c_1273158 = _1273078.pf32;
p_1273087 = c_1273158;
goto l1273085;
l1273074: ;
int y_1273076;
y_1273076 = _1273075.qs32;
int x_1273079;
x_1273079 = _1273078.qs32;
int _1273077;
_1273077 = y_1273076 * _1272989;
int _1273080;
_1273080 = _1273077 + x_1273079;
float* idx_1273081;
idx_1273081 = _1010624_1272940 + _1273080;
_1273084 = __ldg(idx_1273081);
p_1273084 = _1273084;
l1273082: ;
_1273084 = p_1273084;
p_1273087 = _1273084;
goto l1273085;
l1273085: ;
_1273087 = p_1273087;
if (_1272965) goto l1273088; else goto l1273152;
l1273152: ;
pbh_lower_1273091 = _1273154;
goto l1273089;
l1273088: ;
union variant_220130 _1265919_4753;
_1265919_4753.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4755;
_1265920_4755.e0 = 1;
_1265920_4755.e1 = _1265919_4753;
pbh_lower_1273091 = _1265920_4755;
goto l1273089;
l1273089: ;
bh_lower_1273091 = pbh_lower_1273091;
int _1273092;
_1273092 = 1 + gid_y_1272975;
bool _1273093;
_1273093 = _1272970 <= _1273092;
if (_1273093) goto l1273094; else goto l1273149;
l1273149: ;
union variant_220130 _1273150;
_1273150.qs32 = _1273092;
struct_BoundaryMode_220129 _1273151;
_1273151.e0 = 0;
_1273151.e1 = _1273150;
pbh_upper_1273097 = _1273151;
goto l1273095;
l1273094: ;
union variant_220130 _1265919_4763;
_1265919_4763.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4765;
_1265920_4765.e0 = 1;
_1265920_4765.e1 = _1265919_4763;
pbh_upper_1273097 = _1265920_4765;
goto l1273095;
l1273095: ;
bh_upper_1273097 = pbh_upper_1273097;
unsigned int _1273100;
_1273100 = bh_upper_1273097.e0;
union variant_220130 _1273107;
_1273107 = bh_lower_1273091.e1;
union variant_220130 _1273104;
_1273104 = bh_upper_1273097.e1;
unsigned int _1273098;
_1273098 = bh_lower_1273091.e0;
bool _1273101;
_1273101 = _1273100 == 0;
bool _1273099;
_1273099 = _1273098 == 0;
bool _1273102;
_1273102 = _1273099 & _1273101;
if (_1273102) goto l1273103; else goto l1273140;
l1273140: ;
bool _1273141;
_1273141 = _1273098 == 1;
if (_1273141) goto l1273142; else goto l1273144;
l1273144: ;
bool _1273145;
_1273145 = _1273100 == 1;
if (_1273145) goto l1273146; else goto l1273148;
l1273148: ;
// bottom: float r4_1265918_4777;
// bottom: p_1273116 = r4_1265918_4777;
goto l1273114;
l1273146: ;
float c_1273147;
c_1273147 = _1273104.pf32;
p_1273116 = c_1273147;
goto l1273114;
l1273142: ;
float c_1273143;
c_1273143 = _1273107.pf32;
p_1273116 = c_1273143;
goto l1273114;
l1273103: ;
int x_1273108;
x_1273108 = _1273107.qs32;
int y_1273105;
y_1273105 = _1273104.qs32;
int _1273106;
_1273106 = y_1273105 * _1272989;
int _1273109;
_1273109 = _1273106 + x_1273108;
float* idx_1273110;
idx_1273110 = _1010624_1272940 + _1273109;
_1273113 = __ldg(idx_1273110);
p_1273113 = _1273113;
l1273111: ;
_1273113 = p_1273113;
p_1273116 = _1273113;
goto l1273114;
l1273114: ;
_1273116 = p_1273116;
float _1273130;
_1273130 = 2.500000e-01f * _1273029;
float _1273127;
_1273127 = _1273126;
float _1273121;
_1273121 = 2.000000e-01f * _1273000;
float _1273132;
_1273132 = 2.500000e-01f * _1273058;
float _1273131;
_1273131 = 0.000000e+00f + _1273130;
int _1273117;
_1273117 = _1010623_1272939.e3;
float _1273134;
_1273134 = 2.500000e-01f * _1273087;
float _1273136;
_1273136 = 2.500000e-01f * _1273116;
float _1273128;
_1273128 = 2.000000e-01f * _1273127;
float _1273129;
_1273129 = _1273121 + _1273128;
float _1273133;
_1273133 = _1273131 + _1273132;
int _1273118;
_1273118 = gid_y_1272975 * _1273117;
float _1273135;
_1273135 = _1273133 + _1273134;
float _1273137;
_1273137 = _1273135 + _1273136;
float val_1273138;
val_1273138 = _1273129 + _1273137;
int _1273119;
_1273119 = _1273118 + gid_x_1272964;
float* idx_1273120;
idx_1273120 = _1010622_1272938 + _1273119;
*idx_1273120 = val_1273138;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1000387(struct_Img_220118 _1000390_1275937, float* _1000391_1275938, struct_Img_220118 _1000392_1275939, float* _1000393_1275940, float* _1000394_1275941, struct_Img_220118 _1000395_1275942) {
int _1275945;
int p_1275945;
int _1275948;
int p_1275948;
int _1275951;
int p_1275951;
int _1275954;
int p_1275954;
int _1275957;
int p_1275957;
int _1275960;
int p_1275960;
int _1275963;
int p_1275963;
struct_BoundaryMode_220129 bh_lower_1275970;
struct_BoundaryMode_220129 pbh_lower_1275970;
float _1275985;
float p_1275985;
float _1275988;
float p_1275988;
struct_BoundaryMode_220129 bh_lower_1275992;
struct_BoundaryMode_220129 pbh_lower_1275992;
float _1276003;
float p_1276003;
float _1276006;
float p_1276006;
struct_BoundaryMode_220129 bh_lower_1276012;
struct_BoundaryMode_220129 pbh_lower_1276012;
float _1276022;
float p_1276022;
float _1276025;
float p_1276025;
struct_BoundaryMode_220129 bh_lower_1276031;
struct_BoundaryMode_220129 pbh_lower_1276031;
float _1276041;
float p_1276041;
float _1276044;
float p_1276044;
struct_BoundaryMode_220129 bh_lower_1276048;
struct_BoundaryMode_220129 pbh_lower_1276048;
float _1276060;
float p_1276060;
float _1276063;
float p_1276063;
_1275945 = threadIdx_x();
p_1275945 = _1275945;
l1275943: ;
_1275945 = p_1275945;
_1275948 = blockDim_x();
p_1275948 = _1275948;
l1275946: ;
_1275948 = p_1275948;
_1275951 = blockIdx_x();
p_1275951 = _1275951;
l1275949: ;
_1275951 = p_1275951;
_1275954 = threadIdx_y();
p_1275954 = _1275954;
l1275952: ;
_1275954 = p_1275954;
_1275957 = blockDim_y();
p_1275957 = _1275957;
l1275955: ;
_1275957 = p_1275957;
_1275960 = blockIdx_y();
p_1275960 = _1275960;
l1275958: ;
_1275960 = p_1275960;
_1275963 = blockDim_y();
p_1275963 = _1275963;
l1275961: ;
_1275963 = p_1275963;
int _1275964;
_1275964 = _1275948 * _1275951;
int gid_x_1275965;
gid_x_1275965 = _1275945 + _1275964;
union variant_220130 _1276093;
_1276093.qs32 = gid_x_1275965;
bool _1275966;
_1275966 = gid_x_1275965 < 0;
struct_BoundaryMode_220129 _1276094;
_1276094.e0 = 0;
_1276094.e1 = _1276093;
if (_1275966) goto l1275967; else goto l1276123;
l1276123: ;
pbh_lower_1275970 = _1276094;
goto l1275968;
l1275967: ;
union variant_220130 _1265919_4790;
_1265919_4790.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4792;
_1265920_4792.e0 = 1;
_1265920_4792.e1 = _1265919_4790;
pbh_lower_1275970 = _1265920_4792;
goto l1275968;
l1275968: ;
bh_lower_1275970 = pbh_lower_1275970;
int _1275974;
_1275974 = _1275957 * _1275960;
unsigned int _1275971;
_1275971 = bh_lower_1275970.e0;
bool _1275972;
_1275972 = _1275971 == 0;
int gid_y_1275975;
gid_y_1275975 = _1275954 + _1275974;
union variant_220130 _1275979;
_1275979 = bh_lower_1275970.e1;
int _1275977;
_1275977 = _1000390_1275937.e3;
int _1275976;
_1275976 = 1 + gid_y_1275975;
int _1275978;
_1275978 = _1275976 * _1275977;
if (_1275972) goto l1275973; else goto l1276118;
l1276118: ;
bool _1276119;
_1276119 = _1275971 == 1;
if (_1276119) goto l1276120; else goto l1276122;
l1276122: ;
// bottom: float r4_1265918_4802;
// bottom: p_1275988 = r4_1265918_4802;
goto l1275986;
l1276120: ;
float c_1276121;
c_1276121 = _1275979.pf32;
p_1275988 = c_1276121;
goto l1275986;
l1275973: ;
int x_1275980;
x_1275980 = _1275979.qs32;
int _1275981;
_1275981 = _1275978 + x_1275980;
float* idx_1275982;
idx_1275982 = _1000391_1275938 + _1275981;
_1275985 = __ldg(idx_1275982);
p_1275985 = _1275985;
l1275983: ;
_1275985 = p_1275985;
p_1275988 = _1275985;
goto l1275986;
l1275986: ;
_1275988 = p_1275988;
int _1276069;
_1276069 = _1000392_1275939.e3;
int _1276070;
_1276070 = _1275976 * _1276069;
int _1276071;
_1276071 = _1276070 + gid_x_1275965;
float* idx_1276072;
idx_1276072 = _1000394_1275941 + _1276071;
float _1276073;
_1276073 = *idx_1276072;
if (_1275966) goto l1275989; else goto l1276117;
l1276117: ;
pbh_lower_1275992 = _1276094;
goto l1275990;
l1275989: ;
union variant_220130 _1265919_4804;
_1265919_4804.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4806;
_1265920_4806.e0 = 1;
_1265920_4806.e1 = _1265919_4804;
pbh_lower_1275992 = _1265920_4806;
goto l1275990;
l1275990: ;
bh_lower_1275992 = pbh_lower_1275992;
unsigned int _1275993;
_1275993 = bh_lower_1275992.e0;
union variant_220130 _1275997;
_1275997 = bh_lower_1275992.e1;
bool _1275994;
_1275994 = _1275993 == 0;
if (_1275994) goto l1275995; else goto l1276111;
l1276111: ;
bool _1276112;
_1276112 = _1275993 == 1;
if (_1276112) goto l1276113; else goto l1276115;
l1276115: ;
// bottom: float r4_1265918_4814;
// bottom: p_1276006 = r4_1265918_4814;
goto l1276004;
l1276113: ;
float c_1276114;
c_1276114 = _1275997.pf32;
p_1276006 = c_1276114;
goto l1276004;
l1275995: ;
int _1275996;
_1275996 = gid_y_1275975 * _1275977;
int x_1275998;
x_1275998 = _1275997.qs32;
int _1275999;
_1275999 = _1275996 + x_1275998;
float* idx_1276000;
idx_1276000 = _1000391_1275938 + _1275999;
_1276003 = __ldg(idx_1276000);
p_1276003 = _1276003;
l1276001: ;
_1276003 = p_1276003;
p_1276006 = _1276003;
goto l1276004;
l1276004: ;
_1276006 = p_1276006;
int _1276007;
_1276007 = -1 + gid_x_1275965;
bool _1276008;
_1276008 = _1276007 < 0;
if (_1276008) goto l1276009; else goto l1276108;
l1276108: ;
union variant_220130 _1276109;
_1276109.qs32 = _1276007;
struct_BoundaryMode_220129 _1276110;
_1276110.e0 = 0;
_1276110.e1 = _1276109;
pbh_lower_1276012 = _1276110;
goto l1276010;
l1276009: ;
union variant_220130 _1265919_4820;
_1265919_4820.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4822;
_1265920_4822.e0 = 1;
_1265920_4822.e1 = _1265919_4820;
pbh_lower_1276012 = _1265920_4822;
goto l1276010;
l1276010: ;
bh_lower_1276012 = pbh_lower_1276012;
unsigned int _1276013;
_1276013 = bh_lower_1276012.e0;
bool _1276014;
_1276014 = _1276013 == 0;
union variant_220130 _1276016;
_1276016 = bh_lower_1276012.e1;
if (_1276014) goto l1276015; else goto l1276103;
l1276103: ;
bool _1276104;
_1276104 = _1276013 == 1;
if (_1276104) goto l1276105; else goto l1276107;
l1276107: ;
// bottom: float r4_1265918_4830;
// bottom: p_1276025 = r4_1265918_4830;
goto l1276023;
l1276105: ;
float c_1276106;
c_1276106 = _1276016.pf32;
p_1276025 = c_1276106;
goto l1276023;
l1276015: ;
int x_1276017;
x_1276017 = _1276016.qs32;
int _1276018;
_1276018 = _1275978 + x_1276017;
float* idx_1276019;
idx_1276019 = _1000391_1275938 + _1276018;
_1276022 = __ldg(idx_1276019);
p_1276022 = _1276022;
l1276020: ;
_1276022 = p_1276022;
p_1276025 = _1276022;
goto l1276023;
l1276023: ;
_1276025 = p_1276025;
int _1276026;
_1276026 = 1 + gid_x_1275965;
bool _1276027;
_1276027 = _1276026 < 0;
if (_1276027) goto l1276028; else goto l1276100;
l1276100: ;
union variant_220130 _1276101;
_1276101.qs32 = _1276026;
struct_BoundaryMode_220129 _1276102;
_1276102.e0 = 0;
_1276102.e1 = _1276101;
pbh_lower_1276031 = _1276102;
goto l1276029;
l1276028: ;
union variant_220130 _1265919_4836;
_1265919_4836.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4838;
_1265920_4838.e0 = 1;
_1265920_4838.e1 = _1265919_4836;
pbh_lower_1276031 = _1265920_4838;
goto l1276029;
l1276029: ;
bh_lower_1276031 = pbh_lower_1276031;
union variant_220130 _1276035;
_1276035 = bh_lower_1276031.e1;
unsigned int _1276032;
_1276032 = bh_lower_1276031.e0;
bool _1276033;
_1276033 = _1276032 == 0;
if (_1276033) goto l1276034; else goto l1276095;
l1276095: ;
bool _1276096;
_1276096 = _1276032 == 1;
if (_1276096) goto l1276097; else goto l1276099;
l1276099: ;
// bottom: float r4_1265918_4846;
// bottom: p_1276044 = r4_1265918_4846;
goto l1276042;
l1276097: ;
float c_1276098;
c_1276098 = _1276035.pf32;
p_1276044 = c_1276098;
goto l1276042;
l1276034: ;
int x_1276036;
x_1276036 = _1276035.qs32;
int _1276037;
_1276037 = _1275978 + x_1276036;
float* idx_1276038;
idx_1276038 = _1000391_1275938 + _1276037;
_1276041 = __ldg(idx_1276038);
p_1276041 = _1276041;
l1276039: ;
_1276041 = p_1276041;
p_1276044 = _1276041;
goto l1276042;
l1276042: ;
_1276044 = p_1276044;
if (_1275966) goto l1276045; else goto l1276092;
l1276092: ;
pbh_lower_1276048 = _1276094;
goto l1276046;
l1276045: ;
union variant_220130 _1265919_4847;
_1265919_4847.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4849;
_1265920_4849.e0 = 1;
_1265920_4849.e1 = _1265919_4847;
pbh_lower_1276048 = _1265920_4849;
goto l1276046;
l1276046: ;
bh_lower_1276048 = pbh_lower_1276048;
union variant_220130 _1276054;
_1276054 = bh_lower_1276048.e1;
unsigned int _1276049;
_1276049 = bh_lower_1276048.e0;
bool _1276050;
_1276050 = _1276049 == 0;
if (_1276050) goto l1276051; else goto l1276087;
l1276087: ;
bool _1276088;
_1276088 = _1276049 == 1;
if (_1276088) goto l1276089; else goto l1276091;
l1276091: ;
// bottom: float r4_1265918_4857;
// bottom: p_1276063 = r4_1265918_4857;
goto l1276061;
l1276089: ;
float c_1276090;
c_1276090 = _1276054.pf32;
p_1276063 = c_1276090;
goto l1276061;
l1276051: ;
int x_1276055;
x_1276055 = _1276054.qs32;
int _1276052;
_1276052 = 2 + gid_y_1275975;
int _1276053;
_1276053 = _1276052 * _1275977;
int _1276056;
_1276056 = _1276053 + x_1276055;
float* idx_1276057;
idx_1276057 = _1000391_1275938 + _1276056;
_1276060 = __ldg(idx_1276057);
p_1276060 = _1276060;
l1276058: ;
_1276060 = p_1276060;
p_1276063 = _1276060;
goto l1276061;
l1276061: ;
_1276063 = p_1276063;
float _1276079;
_1276079 = 2.500000e-01f * _1276025;
float _1276077;
_1276077 = 2.500000e-01f * _1276006;
float _1276068;
_1276068 = 2.000000e-01f * _1275988;
float _1276074;
_1276074 = _1276073;
float _1276083;
_1276083 = 2.500000e-01f * _1276063;
float _1276081;
_1276081 = 2.500000e-01f * _1276044;
float _1276078;
_1276078 = 0.000000e+00f + _1276077;
int _1276064;
_1276064 = _1000395_1275942.e3;
float _1276080;
_1276080 = _1276078 + _1276079;
float _1276075;
_1276075 = 2.000000e-01f * _1276074;
float _1276082;
_1276082 = _1276080 + _1276081;
int _1276065;
_1276065 = _1275976 * _1276064;
float _1276076;
_1276076 = _1276068 + _1276075;
float _1276084;
_1276084 = _1276082 + _1276083;
int _1276066;
_1276066 = _1276065 + gid_x_1275965;
float val_1276085;
val_1276085 = _1276076 + _1276084;
float* idx_1276067;
idx_1276067 = _1000393_1275940 + _1276066;
*idx_1276067 = val_1276085;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_998812(float* _998815_1278889, float* _998816_1278890, int _998817_1278891) {
int _1278894;
int p_1278894;
int _1278897;
int p_1278897;
int _1278900;
int p_1278900;
int _1278903;
int p_1278903;
int _1278906;
int p_1278906;
int _1278909;
int p_1278909;
int _1278912;
int p_1278912;
int converge_1278920;
int pconverge_1278920;
float _1278928;
float p_1278928;
int converge_1278933;
int pconverge_1278933;
float _1278940;
float p_1278940;
int converge_1278943;
int pconverge_1278943;
float _1278948;
float p_1278948;
int converge_1278953;
int pconverge_1278953;
float _1278958;
float p_1278958;
int converge_1278961;
int pconverge_1278961;
float _1278968;
float p_1278968;
_1278894 = threadIdx_x();
p_1278894 = _1278894;
l1278892: ;
_1278894 = p_1278894;
_1278897 = blockDim_x();
p_1278897 = _1278897;
l1278895: ;
_1278897 = p_1278897;
_1278900 = blockIdx_x();
p_1278900 = _1278900;
l1278898: ;
_1278900 = p_1278900;
_1278903 = threadIdx_y();
p_1278903 = _1278903;
l1278901: ;
_1278903 = p_1278903;
_1278906 = blockDim_y();
p_1278906 = _1278906;
l1278904: ;
_1278906 = p_1278906;
_1278909 = blockIdx_y();
p_1278909 = _1278909;
l1278907: ;
_1278909 = p_1278909;
_1278912 = blockDim_y();
p_1278912 = _1278912;
l1278910: ;
_1278912 = p_1278912;
int _1278915;
_1278915 = _1278897 * _1278900;
int _1278913;
_1278913 = _998817_1278891 - 128;
int _1278914;
_1278914 = _1278913 + _1278894;
int gid_x_1278916;
gid_x_1278916 = _1278914 + _1278915;
bool _1278917;
_1278917 = _998817_1278891 <= gid_x_1278916;
int _1278949;
_1278949 = 1 + gid_x_1278916;
int _1278989;
_1278989 = _1278949 - _998817_1278891;
int _1278990;
_1278990 = _998817_1278891 - _1278989;
if (_1278917) goto l1278918; else goto l1279000;
l1279000: ;
pconverge_1278920 = gid_x_1278916;
goto l1278919;
l1278918: ;
pconverge_1278920 = _1278990;
goto l1278919;
l1278919: ;
converge_1278920 = pconverge_1278920;
int _1278921;
_1278921 = _1278906 * _1278909;
int gid_y_1278922;
gid_y_1278922 = _1278903 + _1278921;
int _1278923;
_1278923 = gid_y_1278922 * _998817_1278891;
int _1278924;
_1278924 = _1278923 + converge_1278920;
float* idx_1278925;
idx_1278925 = _998815_1278889 + _1278924;
_1278928 = __ldg(idx_1278925);
p_1278928 = _1278928;
l1278926: ;
_1278928 = p_1278928;
int _1278929;
_1278929 = -1 + gid_x_1278916;
bool _1278930;
_1278930 = _998817_1278891 <= _1278929;
if (_1278930) goto l1278931; else goto l1278999;
l1278999: ;
pconverge_1278933 = _1278929;
goto l1278932;
l1278931: ;
int _1278997;
_1278997 = gid_x_1278916 - _998817_1278891;
int _1278998;
_1278998 = _998817_1278891 - _1278997;
pconverge_1278933 = _1278998;
goto l1278932;
l1278932: ;
converge_1278933 = pconverge_1278933;
int _1278934;
_1278934 = 1 + gid_y_1278922;
int _1278935;
_1278935 = _1278934 * _998817_1278891;
int _1278936;
_1278936 = _1278935 + converge_1278933;
float* idx_1278937;
idx_1278937 = _998815_1278889 + _1278936;
_1278940 = __ldg(idx_1278937);
p_1278940 = _1278940;
l1278938: ;
_1278940 = p_1278940;
if (_1278917) goto l1278941; else goto l1278996;
l1278996: ;
pconverge_1278943 = gid_x_1278916;
goto l1278942;
l1278941: ;
pconverge_1278943 = _1278990;
goto l1278942;
l1278942: ;
converge_1278943 = pconverge_1278943;
int _1278944;
_1278944 = _1278935 + converge_1278943;
float* idx_1278945;
idx_1278945 = _998815_1278889 + _1278944;
_1278948 = __ldg(idx_1278945);
p_1278948 = _1278948;
l1278946: ;
_1278948 = p_1278948;
bool _1278950;
_1278950 = _998817_1278891 <= _1278949;
if (_1278950) goto l1278951; else goto l1278995;
l1278995: ;
pconverge_1278953 = _1278949;
goto l1278952;
l1278951: ;
int _1278992;
_1278992 = 2 + gid_x_1278916;
int _1278993;
_1278993 = _1278992 - _998817_1278891;
int _1278994;
_1278994 = _998817_1278891 - _1278993;
pconverge_1278953 = _1278994;
goto l1278952;
l1278952: ;
converge_1278953 = pconverge_1278953;
int _1278954;
_1278954 = _1278935 + converge_1278953;
float* idx_1278955;
idx_1278955 = _998815_1278889 + _1278954;
_1278958 = __ldg(idx_1278955);
p_1278958 = _1278958;
l1278956: ;
_1278958 = p_1278958;
if (_1278917) goto l1278959; else goto l1278991;
l1278991: ;
pconverge_1278961 = gid_x_1278916;
goto l1278960;
l1278959: ;
pconverge_1278961 = _1278990;
goto l1278960;
l1278960: ;
converge_1278961 = pconverge_1278961;
int _1278962;
_1278962 = 2 + gid_y_1278922;
int _1278963;
_1278963 = _1278962 * _998817_1278891;
int _1278964;
_1278964 = _1278963 + converge_1278961;
float* idx_1278965;
idx_1278965 = _998815_1278889 + _1278964;
_1278968 = __ldg(idx_1278965);
p_1278968 = _1278968;
l1278966: ;
_1278968 = p_1278968;
float _1278978;
_1278978 = 1.000000e+00f * _1278928;
float _1278982;
_1278982 = -4.000000e+00f * _1278948;
float _1278984;
_1278984 = 1.000000e+00f * _1278958;
float _1278980;
_1278980 = 1.000000e+00f * _1278940;
int _1278969;
_1278969 = 4 * _998817_1278891;
float _1278986;
_1278986 = 1.000000e+00f * _1278968;
int _1278970;
_1278970 = 64 + _1278969;
int _1278971;
_1278971 = _1278970 - 1;
float _1278979;
_1278979 = 0.000000e+00f + _1278978;
float _1278981;
_1278981 = _1278979 + _1278980;
int _1278972;
_1278972 = _1278971 / 64;
float _1278983;
_1278983 = _1278981 + _1278982;
int _1278973;
_1278973 = 64 * _1278972;
float _1278985;
_1278985 = _1278983 + _1278984;
int stride_1278974;
stride_1278974 = _1278973 / 4;
float _1278987;
_1278987 = _1278985 + _1278986;
int _1278975;
_1278975 = _1278934 * stride_1278974;
int _1278976;
_1278976 = _1278975 + gid_x_1278916;
float* idx_1278977;
idx_1278977 = _998816_1278890 + _1278976;
*idx_1278977 = _1278987;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1037483(struct_Img_220118 _1037486_1284538, struct_Img_220118 _1037487_1284539, float* _1037488_1284540, float* _1037489_1284541) {
int threadIdx_x_1284544;
int pthreadIdx_x_1284544;
int blockDim_x_1284547;
int pblockDim_x_1284547;
int blockIdx_x_1284550;
int pblockIdx_x_1284550;
int _1284553;
int p_1284553;
int _1284556;
int p_1284556;
int _1284559;
int p_1284559;
int _1284562;
int p_1284562;
float _1284581;
float p_1284581;
float _1284589;
float p_1284589;
float _1284599;
float p_1284599;
float _1284606;
float p_1284606;
threadIdx_x_1284544 = threadIdx_x();
pthreadIdx_x_1284544 = threadIdx_x_1284544;
l1284542: ;
threadIdx_x_1284544 = pthreadIdx_x_1284544;
blockDim_x_1284547 = blockDim_x();
pblockDim_x_1284547 = blockDim_x_1284547;
l1284545: ;
blockDim_x_1284547 = pblockDim_x_1284547;
blockIdx_x_1284550 = blockIdx_x();
pblockIdx_x_1284550 = blockIdx_x_1284550;
l1284548: ;
blockIdx_x_1284550 = pblockIdx_x_1284550;
_1284553 = threadIdx_y();
p_1284553 = _1284553;
l1284551: ;
_1284553 = p_1284553;
_1284556 = blockDim_y();
p_1284556 = _1284556;
l1284554: ;
_1284556 = p_1284556;
_1284559 = blockIdx_y();
p_1284559 = _1284559;
l1284557: ;
_1284559 = p_1284559;
_1284562 = blockDim_y();
p_1284562 = _1284562;
l1284560: ;
_1284562 = p_1284562;
int _1284563;
_1284563 = _1284556 * _1284559;
int _1284573;
_1284573 = _1037487_1284539.e3;
int _1284565;
_1284565 = _1037486_1284538.e3;
int _1284567;
_1284567 = blockDim_x_1284547 * blockIdx_x_1284550;
int gid_y_1284564;
gid_y_1284564 = _1284553 + _1284563;
int _1284574;
_1284574 = gid_y_1284564 * _1284573;
int _1284566;
_1284566 = gid_y_1284564 * _1284565;
int _1284568;
_1284568 = threadIdx_x_1284544 + _1284567;
int _1284575;
_1284575 = 2 * _1284574;
int _1284569;
_1284569 = _1284566 + _1284568;
int _1284576;
_1284576 = 2 * _1284568;
int _1284577;
_1284577 = _1284575 + _1284576;
float* idx_1284570;
idx_1284570 = _1037489_1284541 + _1284569;
float* idx_1284578;
idx_1284578 = _1037488_1284540 + _1284577;
float _1284571;
_1284571 = *idx_1284570;
_1284581 = __ldg(idx_1284578);
p_1284581 = _1284581;
l1284579: ;
_1284581 = p_1284581;
int _1284585;
_1284585 = 1 + _1284577;
float _1284582;
_1284582 = _1284571;
float* idx_1284586;
idx_1284586 = _1037488_1284540 + _1284585;
float _1284583;
_1284583 = _1284581 + _1284582;
*idx_1284578 = _1284583;
_1284589 = __ldg(idx_1284586);
p_1284589 = _1284589;
l1284587: ;
_1284589 = p_1284589;
int _1284592;
_1284592 = 2 * gid_y_1284564;
float _1284590;
_1284590 = _1284589 + _1284582;
int _1284593;
_1284593 = 1 + _1284592;
*idx_1284586 = _1284590;
int _1284594;
_1284594 = _1284593 * _1284573;
int _1284595;
_1284595 = _1284594 + _1284576;
float* idx_1284596;
idx_1284596 = _1037488_1284540 + _1284595;
_1284599 = __ldg(idx_1284596);
p_1284599 = _1284599;
l1284597: ;
_1284599 = p_1284599;
int _1284602;
_1284602 = 1 + _1284595;
float* idx_1284603;
idx_1284603 = _1037488_1284540 + _1284602;
float _1284600;
_1284600 = _1284599 + _1284582;
*idx_1284596 = _1284600;
_1284606 = __ldg(idx_1284603);
p_1284606 = _1284606;
l1284604: ;
_1284606 = p_1284606;
float _1284607;
_1284607 = _1284606 + _1284582;
*idx_1284603 = _1284607;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_997261(float* _997264_1275725, float* _997265_1275726, int _997266_1275727) {
int _1275730;
int p_1275730;
int _1275733;
int p_1275733;
int _1275736;
int p_1275736;
int _1275739;
int p_1275739;
int _1275742;
int p_1275742;
int _1275745;
int p_1275745;
int _1275748;
int p_1275748;
int converge_1275755;
int pconverge_1275755;
float _1275764;
float p_1275764;
int converge_1275768;
int pconverge_1275768;
float _1275775;
float p_1275775;
int converge_1275778;
int pconverge_1275778;
float _1275785;
float p_1275785;
int converge_1275788;
int pconverge_1275788;
float _1275795;
float p_1275795;
int converge_1275800;
int pconverge_1275800;
float _1275807;
float p_1275807;
_1275730 = threadIdx_x();
p_1275730 = _1275730;
l1275728: ;
_1275730 = p_1275730;
_1275733 = blockDim_x();
p_1275733 = _1275733;
l1275731: ;
_1275733 = p_1275733;
_1275736 = blockIdx_x();
p_1275736 = _1275736;
l1275734: ;
_1275736 = p_1275736;
_1275739 = threadIdx_y();
p_1275739 = _1275739;
l1275737: ;
_1275739 = p_1275739;
_1275742 = blockDim_y();
p_1275742 = _1275742;
l1275740: ;
_1275742 = p_1275742;
_1275745 = blockIdx_y();
p_1275745 = _1275745;
l1275743: ;
_1275745 = p_1275745;
_1275748 = blockDim_y();
p_1275748 = _1275748;
l1275746: ;
_1275748 = p_1275748;
int _1275749;
_1275749 = _1275742 * _1275745;
int gid_y_1275750;
gid_y_1275750 = _1275739 + _1275749;
int _1275751;
_1275751 = -1 + gid_y_1275750;
bool _1275752;
_1275752 = _1275751 < 0;
if (_1275752) goto l1275753; else goto l1275839;
l1275839: ;
pconverge_1275755 = _1275751;
goto l1275754;
l1275753: ;
int _1275837;
_1275837 = 0 - _1275751;
int _1275838;
_1275838 = _1275837 - 1;
pconverge_1275755 = _1275838;
goto l1275754;
l1275754: ;
converge_1275755 = pconverge_1275755;
int _1275756;
_1275756 = converge_1275755 * _997266_1275727;
int _1275757;
_1275757 = _1275733 * _1275736;
int gid_x_1275758;
gid_x_1275758 = _1275730 + _1275757;
int _1275759;
_1275759 = _1275756 + gid_x_1275758;
int _1275760;
_1275760 = 128 + _1275759;
float* idx_1275761;
idx_1275761 = _997264_1275725 + _1275760;
_1275764 = __ldg(idx_1275761);
p_1275764 = _1275764;
l1275762: ;
_1275764 = p_1275764;
int _1275832;
_1275832 = 0 - gid_y_1275750;
int _1275833;
_1275833 = _1275832 - 1;
bool _1275765;
_1275765 = gid_y_1275750 < 0;
if (_1275765) goto l1275766; else goto l1275836;
l1275836: ;
pconverge_1275768 = gid_y_1275750;
goto l1275767;
l1275766: ;
pconverge_1275768 = _1275833;
goto l1275767;
l1275767: ;
converge_1275768 = pconverge_1275768;
int _1275769;
_1275769 = converge_1275768 * _997266_1275727;
int _1275770;
_1275770 = _1275769 + gid_x_1275758;
int _1275771;
_1275771 = 127 + _1275770;
float* idx_1275772;
idx_1275772 = _997264_1275725 + _1275771;
_1275775 = __ldg(idx_1275772);
p_1275775 = _1275775;
l1275773: ;
_1275775 = p_1275775;
if (_1275765) goto l1275776; else goto l1275835;
l1275835: ;
pconverge_1275778 = gid_y_1275750;
goto l1275777;
l1275776: ;
pconverge_1275778 = _1275833;
goto l1275777;
l1275777: ;
converge_1275778 = pconverge_1275778;
int _1275779;
_1275779 = converge_1275778 * _997266_1275727;
int _1275780;
_1275780 = _1275779 + gid_x_1275758;
int _1275781;
_1275781 = 128 + _1275780;
float* idx_1275782;
idx_1275782 = _997264_1275725 + _1275781;
_1275785 = __ldg(idx_1275782);
p_1275785 = _1275785;
l1275783: ;
_1275785 = p_1275785;
if (_1275765) goto l1275786; else goto l1275834;
l1275834: ;
pconverge_1275788 = gid_y_1275750;
goto l1275787;
l1275786: ;
pconverge_1275788 = _1275833;
goto l1275787;
l1275787: ;
converge_1275788 = pconverge_1275788;
int _1275789;
_1275789 = converge_1275788 * _997266_1275727;
int _1275790;
_1275790 = _1275789 + gid_x_1275758;
int _1275791;
_1275791 = 129 + _1275790;
float* idx_1275792;
idx_1275792 = _997264_1275725 + _1275791;
_1275795 = __ldg(idx_1275792);
p_1275795 = _1275795;
l1275793: ;
_1275795 = p_1275795;
int _1275796;
_1275796 = 1 + gid_y_1275750;
bool _1275797;
_1275797 = _1275796 < 0;
if (_1275797) goto l1275798; else goto l1275831;
l1275831: ;
pconverge_1275800 = _1275796;
goto l1275799;
l1275798: ;
int _1275829;
_1275829 = 0 - _1275796;
int _1275830;
_1275830 = _1275829 - 1;
pconverge_1275800 = _1275830;
goto l1275799;
l1275799: ;
converge_1275800 = pconverge_1275800;
int _1275801;
_1275801 = converge_1275800 * _997266_1275727;
int _1275802;
_1275802 = _1275801 + gid_x_1275758;
int _1275803;
_1275803 = 128 + _1275802;
float* idx_1275804;
idx_1275804 = _997264_1275725 + _1275803;
_1275807 = __ldg(idx_1275804);
p_1275807 = _1275807;
l1275805: ;
_1275807 = p_1275807;
float _1275820;
_1275820 = 1.000000e+00f * _1275775;
float _1275826;
_1275826 = 1.000000e+00f * _1275807;
float _1275818;
_1275818 = 1.000000e+00f * _1275764;
float _1275822;
_1275822 = -4.000000e+00f * _1275785;
float _1275819;
_1275819 = 0.000000e+00f + _1275818;
float _1275824;
_1275824 = 1.000000e+00f * _1275795;
int _1275808;
_1275808 = 4 * _997266_1275727;
float _1275821;
_1275821 = _1275819 + _1275820;
float _1275823;
_1275823 = _1275821 + _1275822;
float _1275825;
_1275825 = _1275823 + _1275824;
int _1275809;
_1275809 = 64 + _1275808;
float _1275827;
_1275827 = _1275825 + _1275826;
int _1275810;
_1275810 = _1275809 - 1;
int _1275811;
_1275811 = _1275810 / 64;
int _1275812;
_1275812 = 64 * _1275811;
int stride_1275813;
stride_1275813 = _1275812 / 4;
int _1275814;
_1275814 = gid_y_1275750 * stride_1275813;
int _1275815;
_1275815 = _1275814 + gid_x_1275758;
int _1275816;
_1275816 = 128 + _1275815;
float* idx_1275817;
idx_1275817 = _997265_1275726 + _1275816;
*idx_1275817 = _1275827;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1040216(struct_Img_220118 _1040219_1276380, struct_Img_220118 _1040220_1276381, float* _1040221_1276382, struct_Img_220118 _1040222_1276383, float* _1040223_1276384, float* _1040224_1276385) {
int _1276388;
int p_1276388;
int _1276391;
int p_1276391;
int _1276394;
int p_1276394;
int _1276397;
int p_1276397;
int _1276400;
int p_1276400;
int _1276403;
int p_1276403;
int _1276406;
int p_1276406;
struct_BoundaryMode_220129 bh_upper_1276417;
struct_BoundaryMode_220129 pbh_upper_1276417;
float _1276432;
float p_1276432;
float _1276435;
float p_1276435;
struct_BoundaryMode_220129 bh_upper_1276441;
struct_BoundaryMode_220129 pbh_upper_1276441;
float _1276453;
float p_1276453;
float _1276456;
float p_1276456;
struct_BoundaryMode_220129 bh_upper_1276460;
struct_BoundaryMode_220129 pbh_upper_1276460;
float _1276472;
float p_1276472;
float _1276475;
float p_1276475;
struct_BoundaryMode_220129 bh_upper_1276479;
struct_BoundaryMode_220129 pbh_upper_1276479;
float _1276491;
float p_1276491;
float _1276494;
float p_1276494;
struct_BoundaryMode_220129 bh_upper_1276500;
struct_BoundaryMode_220129 pbh_upper_1276500;
float _1276512;
float p_1276512;
float _1276515;
float p_1276515;
_1276388 = threadIdx_x();
p_1276388 = _1276388;
l1276386: ;
_1276388 = p_1276388;
_1276391 = blockDim_x();
p_1276391 = _1276391;
l1276389: ;
_1276391 = p_1276391;
_1276394 = blockIdx_x();
p_1276394 = _1276394;
l1276392: ;
_1276394 = p_1276394;
_1276397 = threadIdx_y();
p_1276397 = _1276397;
l1276395: ;
_1276397 = p_1276397;
_1276400 = blockDim_y();
p_1276400 = _1276400;
l1276398: ;
_1276400 = p_1276400;
_1276403 = blockIdx_y();
p_1276403 = _1276403;
l1276401: ;
_1276403 = p_1276403;
_1276406 = blockDim_y();
p_1276406 = _1276406;
l1276404: ;
_1276406 = p_1276406;
int _1276407;
_1276407 = _1040219_1276380.e2;
int _1276408;
_1276408 = _1040220_1276381.e2;
int _1276411;
_1276411 = _1276400 * _1276403;
int _1276409;
_1276409 = _1276408 - 1;
int _1276410;
_1276410 = _1276409 + _1276397;
int gid_y_1276412;
gid_y_1276412 = _1276410 + _1276411;
bool _1276413;
_1276413 = _1276407 <= gid_y_1276412;
union variant_220130 _1276555;
_1276555.qs32 = gid_y_1276412;
struct_BoundaryMode_220129 _1276556;
_1276556.e0 = 0;
_1276556.e1 = _1276555;
if (_1276413) goto l1276414; else goto l1276577;
l1276577: ;
pbh_upper_1276417 = _1276556;
goto l1276415;
l1276414: ;
union variant_220130 _1265919_4928;
_1265919_4928.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4930;
_1265920_4930.e0 = 1;
_1265920_4930.e1 = _1265919_4928;
pbh_upper_1276417 = _1265920_4930;
goto l1276415;
l1276415: ;
bh_upper_1276417 = pbh_upper_1276417;
union variant_220130 _1276421;
_1276421 = bh_upper_1276417.e1;
int _1276423;
_1276423 = _1040219_1276380.e3;
unsigned int _1276418;
_1276418 = bh_upper_1276417.e0;
int _1276425;
_1276425 = _1276391 * _1276394;
int gid_x_1276426;
gid_x_1276426 = _1276388 + _1276425;
bool _1276419;
_1276419 = _1276418 == 0;
if (_1276419) goto l1276420; else goto l1276572;
l1276572: ;
bool _1276573;
_1276573 = _1276418 == 1;
if (_1276573) goto l1276574; else goto l1276576;
l1276576: ;
// bottom: float r4_1265918_4939;
// bottom: p_1276435 = r4_1265918_4939;
goto l1276433;
l1276574: ;
float c_1276575;
c_1276575 = _1276421.pf32;
p_1276435 = c_1276575;
goto l1276433;
l1276420: ;
int y_1276422;
y_1276422 = _1276421.qs32;
int _1276424;
_1276424 = y_1276422 * _1276423;
int _1276427;
_1276427 = _1276424 + gid_x_1276426;
int _1276428;
_1276428 = 128 + _1276427;
float* idx_1276429;
idx_1276429 = _1040221_1276382 + _1276428;
_1276432 = __ldg(idx_1276429);
p_1276432 = _1276432;
l1276430: ;
_1276432 = p_1276432;
p_1276435 = _1276432;
goto l1276433;
l1276433: ;
_1276435 = p_1276435;
int _1276436;
_1276436 = -1 + gid_y_1276412;
int _1276522;
_1276522 = _1040222_1276383.e3;
bool _1276437;
_1276437 = _1276407 <= _1276436;
int _1276523;
_1276523 = gid_y_1276412 * _1276522;
int _1276524;
_1276524 = _1276523 + gid_x_1276426;
int _1276525;
_1276525 = 128 + _1276524;
float* idx_1276526;
idx_1276526 = _1040224_1276385 + _1276525;
float _1276527;
_1276527 = *idx_1276526;
if (_1276437) goto l1276438; else goto l1276569;
l1276569: ;
union variant_220130 _1276570;
_1276570.qs32 = _1276436;
struct_BoundaryMode_220129 _1276571;
_1276571.e0 = 0;
_1276571.e1 = _1276570;
pbh_upper_1276441 = _1276571;
goto l1276439;
l1276438: ;
union variant_220130 _1265919_4947;
_1265919_4947.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4949;
_1265920_4949.e0 = 1;
_1265920_4949.e1 = _1265919_4947;
pbh_upper_1276441 = _1265920_4949;
goto l1276439;
l1276439: ;
bh_upper_1276441 = pbh_upper_1276441;
unsigned int _1276442;
_1276442 = bh_upper_1276441.e0;
union variant_220130 _1276445;
_1276445 = bh_upper_1276441.e1;
bool _1276443;
_1276443 = _1276442 == 0;
if (_1276443) goto l1276444; else goto l1276563;
l1276563: ;
bool _1276564;
_1276564 = _1276442 == 1;
if (_1276564) goto l1276565; else goto l1276567;
l1276567: ;
// bottom: float r4_1265918_4957;
// bottom: p_1276456 = r4_1265918_4957;
goto l1276454;
l1276565: ;
float c_1276566;
c_1276566 = _1276445.pf32;
p_1276456 = c_1276566;
goto l1276454;
l1276444: ;
int y_1276446;
y_1276446 = _1276445.qs32;
int _1276447;
_1276447 = y_1276446 * _1276423;
int _1276448;
_1276448 = _1276447 + gid_x_1276426;
int _1276449;
_1276449 = 128 + _1276448;
float* idx_1276450;
idx_1276450 = _1040221_1276382 + _1276449;
_1276453 = __ldg(idx_1276450);
p_1276453 = _1276453;
l1276451: ;
_1276453 = p_1276453;
p_1276456 = _1276453;
goto l1276454;
l1276454: ;
_1276456 = p_1276456;
if (_1276413) goto l1276457; else goto l1276562;
l1276562: ;
pbh_upper_1276460 = _1276556;
goto l1276458;
l1276457: ;
union variant_220130 _1265919_4959;
_1265919_4959.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4961;
_1265920_4961.e0 = 1;
_1265920_4961.e1 = _1265919_4959;
pbh_upper_1276460 = _1265920_4961;
goto l1276458;
l1276458: ;
bh_upper_1276460 = pbh_upper_1276460;
union variant_220130 _1276464;
_1276464 = bh_upper_1276460.e1;
unsigned int _1276461;
_1276461 = bh_upper_1276460.e0;
bool _1276462;
_1276462 = _1276461 == 0;
if (_1276462) goto l1276463; else goto l1276557;
l1276557: ;
bool _1276558;
_1276558 = _1276461 == 1;
if (_1276558) goto l1276559; else goto l1276561;
l1276561: ;
// bottom: float r4_1265918_4969;
// bottom: p_1276475 = r4_1265918_4969;
goto l1276473;
l1276559: ;
float c_1276560;
c_1276560 = _1276464.pf32;
p_1276475 = c_1276560;
goto l1276473;
l1276463: ;
int y_1276465;
y_1276465 = _1276464.qs32;
int _1276466;
_1276466 = y_1276465 * _1276423;
int _1276467;
_1276467 = _1276466 + gid_x_1276426;
int _1276468;
_1276468 = 127 + _1276467;
float* idx_1276469;
idx_1276469 = _1040221_1276382 + _1276468;
_1276472 = __ldg(idx_1276469);
p_1276472 = _1276472;
l1276470: ;
_1276472 = p_1276472;
p_1276475 = _1276472;
goto l1276473;
l1276473: ;
_1276475 = p_1276475;
if (_1276413) goto l1276476; else goto l1276554;
l1276554: ;
pbh_upper_1276479 = _1276556;
goto l1276477;
l1276476: ;
union variant_220130 _1265919_4971;
_1265919_4971.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4973;
_1265920_4973.e0 = 1;
_1265920_4973.e1 = _1265919_4971;
pbh_upper_1276479 = _1265920_4973;
goto l1276477;
l1276477: ;
bh_upper_1276479 = pbh_upper_1276479;
union variant_220130 _1276483;
_1276483 = bh_upper_1276479.e1;
unsigned int _1276480;
_1276480 = bh_upper_1276479.e0;
bool _1276481;
_1276481 = _1276480 == 0;
if (_1276481) goto l1276482; else goto l1276549;
l1276549: ;
bool _1276550;
_1276550 = _1276480 == 1;
if (_1276550) goto l1276551; else goto l1276553;
l1276553: ;
// bottom: float r4_1265918_4981;
// bottom: p_1276494 = r4_1265918_4981;
goto l1276492;
l1276551: ;
float c_1276552;
c_1276552 = _1276483.pf32;
p_1276494 = c_1276552;
goto l1276492;
l1276482: ;
int y_1276484;
y_1276484 = _1276483.qs32;
int _1276485;
_1276485 = y_1276484 * _1276423;
int _1276486;
_1276486 = _1276485 + gid_x_1276426;
int _1276487;
_1276487 = 129 + _1276486;
float* idx_1276488;
idx_1276488 = _1040221_1276382 + _1276487;
_1276491 = __ldg(idx_1276488);
p_1276491 = _1276491;
l1276489: ;
_1276491 = p_1276491;
p_1276494 = _1276491;
goto l1276492;
l1276492: ;
_1276494 = p_1276494;
int _1276495;
_1276495 = 1 + gid_y_1276412;
bool _1276496;
_1276496 = _1276407 <= _1276495;
if (_1276496) goto l1276497; else goto l1276546;
l1276546: ;
union variant_220130 _1276547;
_1276547.qs32 = _1276495;
struct_BoundaryMode_220129 _1276548;
_1276548.e0 = 0;
_1276548.e1 = _1276547;
pbh_upper_1276500 = _1276548;
goto l1276498;
l1276497: ;
union variant_220130 _1265919_4987;
_1265919_4987.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_4989;
_1265920_4989.e0 = 1;
_1265920_4989.e1 = _1265919_4987;
pbh_upper_1276500 = _1265920_4989;
goto l1276498;
l1276498: ;
bh_upper_1276500 = pbh_upper_1276500;
union variant_220130 _1276504;
_1276504 = bh_upper_1276500.e1;
unsigned int _1276501;
_1276501 = bh_upper_1276500.e0;
bool _1276502;
_1276502 = _1276501 == 0;
if (_1276502) goto l1276503; else goto l1276541;
l1276541: ;
bool _1276542;
_1276542 = _1276501 == 1;
if (_1276542) goto l1276543; else goto l1276545;
l1276545: ;
// bottom: float r4_1265918_4997;
// bottom: p_1276515 = r4_1265918_4997;
goto l1276513;
l1276543: ;
float c_1276544;
c_1276544 = _1276504.pf32;
p_1276515 = c_1276544;
goto l1276513;
l1276503: ;
int y_1276505;
y_1276505 = _1276504.qs32;
int _1276506;
_1276506 = y_1276505 * _1276423;
int _1276507;
_1276507 = _1276506 + gid_x_1276426;
int _1276508;
_1276508 = 128 + _1276507;
float* idx_1276509;
idx_1276509 = _1040221_1276382 + _1276508;
_1276512 = __ldg(idx_1276509);
p_1276512 = _1276512;
l1276510: ;
_1276512 = p_1276512;
p_1276515 = _1276512;
goto l1276513;
l1276513: ;
_1276515 = p_1276515;
float _1276537;
_1276537 = 2.500000e-01f * _1276515;
float _1276531;
_1276531 = 2.500000e-01f * _1276456;
float _1276528;
_1276528 = _1276527;
float _1276521;
_1276521 = 2.000000e-01f * _1276435;
float _1276529;
_1276529 = 2.000000e-01f * _1276528;
float _1276530;
_1276530 = _1276521 + _1276529;
int _1276516;
_1276516 = _1040220_1276381.e3;
float _1276532;
_1276532 = 0.000000e+00f + _1276531;
float _1276535;
_1276535 = 2.500000e-01f * _1276494;
float _1276533;
_1276533 = 2.500000e-01f * _1276475;
int _1276517;
_1276517 = gid_y_1276412 * _1276516;
float _1276534;
_1276534 = _1276532 + _1276533;
float _1276536;
_1276536 = _1276534 + _1276535;
int _1276518;
_1276518 = _1276517 + gid_x_1276426;
float _1276538;
_1276538 = _1276536 + _1276537;
int _1276519;
_1276519 = 128 + _1276518;
float val_1276539;
val_1276539 = _1276530 + _1276538;
float* idx_1276520;
idx_1276520 = _1040223_1276384 + _1276519;
*idx_1276520 = val_1276539;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1038384(struct_Img_220118 _1038387_1274668, struct_Img_220118 _1038388_1274669, float* _1038389_1274670, struct_Img_220118 _1038390_1274671, float* _1038391_1274672, float* _1038392_1274673) {
int _1274676;
int p_1274676;
int _1274679;
int p_1274679;
int _1274682;
int p_1274682;
int _1274685;
int p_1274685;
int _1274688;
int p_1274688;
int _1274691;
int p_1274691;
int _1274694;
int p_1274694;
struct_BoundaryMode_220129 bh_lower_1274701;
struct_BoundaryMode_220129 pbh_lower_1274701;
float _1274716;
float p_1274716;
float _1274719;
float p_1274719;
struct_BoundaryMode_220129 bh_lower_1274723;
struct_BoundaryMode_220129 pbh_lower_1274723;
float _1274734;
float p_1274734;
float _1274737;
float p_1274737;
struct_BoundaryMode_220129 bh_lower_1274743;
struct_BoundaryMode_220129 pbh_lower_1274743;
float _1274753;
float p_1274753;
float _1274756;
float p_1274756;
struct_BoundaryMode_220129 bh_lower_1274762;
struct_BoundaryMode_220129 pbh_lower_1274762;
float _1274772;
float p_1274772;
float _1274775;
float p_1274775;
struct_BoundaryMode_220129 bh_lower_1274779;
struct_BoundaryMode_220129 pbh_lower_1274779;
float _1274791;
float p_1274791;
float _1274794;
float p_1274794;
_1274676 = threadIdx_x();
p_1274676 = _1274676;
l1274674: ;
_1274676 = p_1274676;
_1274679 = blockDim_x();
p_1274679 = _1274679;
l1274677: ;
_1274679 = p_1274679;
_1274682 = blockIdx_x();
p_1274682 = _1274682;
l1274680: ;
_1274682 = p_1274682;
_1274685 = threadIdx_y();
p_1274685 = _1274685;
l1274683: ;
_1274685 = p_1274685;
_1274688 = blockDim_y();
p_1274688 = _1274688;
l1274686: ;
_1274688 = p_1274688;
_1274691 = blockIdx_y();
p_1274691 = _1274691;
l1274689: ;
_1274691 = p_1274691;
_1274694 = blockDim_y();
p_1274694 = _1274694;
l1274692: ;
_1274694 = p_1274694;
int _1274695;
_1274695 = _1274679 * _1274682;
int gid_x_1274696;
gid_x_1274696 = _1274676 + _1274695;
bool _1274697;
_1274697 = gid_x_1274696 < 0;
union variant_220130 _1274824;
_1274824.qs32 = gid_x_1274696;
struct_BoundaryMode_220129 _1274825;
_1274825.e0 = 0;
_1274825.e1 = _1274824;
if (_1274697) goto l1274698; else goto l1274854;
l1274854: ;
pbh_lower_1274701 = _1274825;
goto l1274699;
l1274698: ;
union variant_220130 _1265919_5012;
_1265919_5012.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5014;
_1265920_5014.e0 = 1;
_1265920_5014.e1 = _1265919_5012;
pbh_lower_1274701 = _1265920_5014;
goto l1274699;
l1274699: ;
bh_lower_1274701 = pbh_lower_1274701;
union variant_220130 _1274710;
_1274710 = bh_lower_1274701.e1;
unsigned int _1274702;
_1274702 = bh_lower_1274701.e0;
int _1274708;
_1274708 = _1038387_1274668.e3;
int _1274705;
_1274705 = _1274688 * _1274691;
bool _1274703;
_1274703 = _1274702 == 0;
int gid_y_1274706;
gid_y_1274706 = _1274685 + _1274705;
int _1274707;
_1274707 = 1 + gid_y_1274706;
int _1274709;
_1274709 = _1274707 * _1274708;
if (_1274703) goto l1274704; else goto l1274849;
l1274849: ;
bool _1274850;
_1274850 = _1274702 == 1;
if (_1274850) goto l1274851; else goto l1274853;
l1274853: ;
// bottom: float r4_1265918_5024;
// bottom: p_1274719 = r4_1265918_5024;
goto l1274717;
l1274851: ;
float c_1274852;
c_1274852 = _1274710.pf32;
p_1274719 = c_1274852;
goto l1274717;
l1274704: ;
int x_1274711;
x_1274711 = _1274710.qs32;
int _1274712;
_1274712 = _1274709 + x_1274711;
float* idx_1274713;
idx_1274713 = _1038389_1274670 + _1274712;
_1274716 = __ldg(idx_1274713);
p_1274716 = _1274716;
l1274714: ;
_1274716 = p_1274716;
p_1274719 = _1274716;
goto l1274717;
l1274717: ;
_1274719 = p_1274719;
int _1274800;
_1274800 = _1038390_1274671.e3;
int _1274801;
_1274801 = _1274707 * _1274800;
int _1274802;
_1274802 = _1274801 + gid_x_1274696;
float* idx_1274803;
idx_1274803 = _1038392_1274673 + _1274802;
float _1274804;
_1274804 = *idx_1274803;
if (_1274697) goto l1274720; else goto l1274848;
l1274848: ;
pbh_lower_1274723 = _1274825;
goto l1274721;
l1274720: ;
union variant_220130 _1265919_5026;
_1265919_5026.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5028;
_1265920_5028.e0 = 1;
_1265920_5028.e1 = _1265919_5026;
pbh_lower_1274723 = _1265920_5028;
goto l1274721;
l1274721: ;
bh_lower_1274723 = pbh_lower_1274723;
union variant_220130 _1274728;
_1274728 = bh_lower_1274723.e1;
unsigned int _1274724;
_1274724 = bh_lower_1274723.e0;
bool _1274725;
_1274725 = _1274724 == 0;
if (_1274725) goto l1274726; else goto l1274842;
l1274842: ;
bool _1274843;
_1274843 = _1274724 == 1;
if (_1274843) goto l1274844; else goto l1274846;
l1274846: ;
// bottom: float r4_1265918_5036;
// bottom: p_1274737 = r4_1265918_5036;
goto l1274735;
l1274844: ;
float c_1274845;
c_1274845 = _1274728.pf32;
p_1274737 = c_1274845;
goto l1274735;
l1274726: ;
int _1274727;
_1274727 = gid_y_1274706 * _1274708;
int x_1274729;
x_1274729 = _1274728.qs32;
int _1274730;
_1274730 = _1274727 + x_1274729;
float* idx_1274731;
idx_1274731 = _1038389_1274670 + _1274730;
_1274734 = __ldg(idx_1274731);
p_1274734 = _1274734;
l1274732: ;
_1274734 = p_1274734;
p_1274737 = _1274734;
goto l1274735;
l1274735: ;
_1274737 = p_1274737;
int _1274738;
_1274738 = -1 + gid_x_1274696;
bool _1274739;
_1274739 = _1274738 < 0;
if (_1274739) goto l1274740; else goto l1274839;
l1274839: ;
union variant_220130 _1274840;
_1274840.qs32 = _1274738;
struct_BoundaryMode_220129 _1274841;
_1274841.e0 = 0;
_1274841.e1 = _1274840;
pbh_lower_1274743 = _1274841;
goto l1274741;
l1274740: ;
union variant_220130 _1265919_5042;
_1265919_5042.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5044;
_1265920_5044.e0 = 1;
_1265920_5044.e1 = _1265919_5042;
pbh_lower_1274743 = _1265920_5044;
goto l1274741;
l1274741: ;
bh_lower_1274743 = pbh_lower_1274743;
union variant_220130 _1274747;
_1274747 = bh_lower_1274743.e1;
unsigned int _1274744;
_1274744 = bh_lower_1274743.e0;
bool _1274745;
_1274745 = _1274744 == 0;
if (_1274745) goto l1274746; else goto l1274834;
l1274834: ;
bool _1274835;
_1274835 = _1274744 == 1;
if (_1274835) goto l1274836; else goto l1274838;
l1274838: ;
// bottom: float r4_1265918_5052;
// bottom: p_1274756 = r4_1265918_5052;
goto l1274754;
l1274836: ;
float c_1274837;
c_1274837 = _1274747.pf32;
p_1274756 = c_1274837;
goto l1274754;
l1274746: ;
int x_1274748;
x_1274748 = _1274747.qs32;
int _1274749;
_1274749 = _1274709 + x_1274748;
float* idx_1274750;
idx_1274750 = _1038389_1274670 + _1274749;
_1274753 = __ldg(idx_1274750);
p_1274753 = _1274753;
l1274751: ;
_1274753 = p_1274753;
p_1274756 = _1274753;
goto l1274754;
l1274754: ;
_1274756 = p_1274756;
int _1274757;
_1274757 = 1 + gid_x_1274696;
bool _1274758;
_1274758 = _1274757 < 0;
if (_1274758) goto l1274759; else goto l1274831;
l1274831: ;
union variant_220130 _1274832;
_1274832.qs32 = _1274757;
struct_BoundaryMode_220129 _1274833;
_1274833.e0 = 0;
_1274833.e1 = _1274832;
pbh_lower_1274762 = _1274833;
goto l1274760;
l1274759: ;
union variant_220130 _1265919_5058;
_1265919_5058.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5060;
_1265920_5060.e0 = 1;
_1265920_5060.e1 = _1265919_5058;
pbh_lower_1274762 = _1265920_5060;
goto l1274760;
l1274760: ;
bh_lower_1274762 = pbh_lower_1274762;
unsigned int _1274763;
_1274763 = bh_lower_1274762.e0;
union variant_220130 _1274766;
_1274766 = bh_lower_1274762.e1;
bool _1274764;
_1274764 = _1274763 == 0;
if (_1274764) goto l1274765; else goto l1274826;
l1274826: ;
bool _1274827;
_1274827 = _1274763 == 1;
if (_1274827) goto l1274828; else goto l1274830;
l1274830: ;
// bottom: float r4_1265918_5068;
// bottom: p_1274775 = r4_1265918_5068;
goto l1274773;
l1274828: ;
float c_1274829;
c_1274829 = _1274766.pf32;
p_1274775 = c_1274829;
goto l1274773;
l1274765: ;
int x_1274767;
x_1274767 = _1274766.qs32;
int _1274768;
_1274768 = _1274709 + x_1274767;
float* idx_1274769;
idx_1274769 = _1038389_1274670 + _1274768;
_1274772 = __ldg(idx_1274769);
p_1274772 = _1274772;
l1274770: ;
_1274772 = p_1274772;
p_1274775 = _1274772;
goto l1274773;
l1274773: ;
_1274775 = p_1274775;
if (_1274697) goto l1274776; else goto l1274823;
l1274823: ;
pbh_lower_1274779 = _1274825;
goto l1274777;
l1274776: ;
union variant_220130 _1265919_5069;
_1265919_5069.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5071;
_1265920_5071.e0 = 1;
_1265920_5071.e1 = _1265919_5069;
pbh_lower_1274779 = _1265920_5071;
goto l1274777;
l1274777: ;
bh_lower_1274779 = pbh_lower_1274779;
unsigned int _1274780;
_1274780 = bh_lower_1274779.e0;
union variant_220130 _1274785;
_1274785 = bh_lower_1274779.e1;
bool _1274781;
_1274781 = _1274780 == 0;
if (_1274781) goto l1274782; else goto l1274818;
l1274818: ;
bool _1274819;
_1274819 = _1274780 == 1;
if (_1274819) goto l1274820; else goto l1274822;
l1274822: ;
// bottom: float r4_1265918_5079;
// bottom: p_1274794 = r4_1265918_5079;
goto l1274792;
l1274820: ;
float c_1274821;
c_1274821 = _1274785.pf32;
p_1274794 = c_1274821;
goto l1274792;
l1274782: ;
int x_1274786;
x_1274786 = _1274785.qs32;
int _1274783;
_1274783 = 2 + gid_y_1274706;
int _1274784;
_1274784 = _1274783 * _1274708;
int _1274787;
_1274787 = _1274784 + x_1274786;
float* idx_1274788;
idx_1274788 = _1038389_1274670 + _1274787;
_1274791 = __ldg(idx_1274788);
p_1274791 = _1274791;
l1274789: ;
_1274791 = p_1274791;
p_1274794 = _1274791;
goto l1274792;
l1274792: ;
_1274794 = p_1274794;
float _1274805;
_1274805 = _1274804;
float _1274806;
_1274806 = 2.000000e-01f * _1274805;
float _1274799;
_1274799 = 2.000000e-01f * _1274719;
float _1274807;
_1274807 = _1274799 + _1274806;
float _1274810;
_1274810 = 2.500000e-01f * _1274756;
float _1274808;
_1274808 = 2.500000e-01f * _1274737;
int _1274795;
_1274795 = _1038388_1274669.e3;
float _1274814;
_1274814 = 2.500000e-01f * _1274794;
float _1274812;
_1274812 = 2.500000e-01f * _1274775;
float _1274809;
_1274809 = 0.000000e+00f + _1274808;
int _1274796;
_1274796 = _1274707 * _1274795;
float _1274811;
_1274811 = _1274809 + _1274810;
int _1274797;
_1274797 = _1274796 + gid_x_1274696;
float _1274813;
_1274813 = _1274811 + _1274812;
float* idx_1274798;
idx_1274798 = _1038391_1274672 + _1274797;
float _1274815;
_1274815 = _1274813 + _1274814;
float val_1274816;
val_1274816 = _1274807 + _1274815;
*idx_1274798 = val_1274816;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1020379(float* _1020382_1283039, struct_Img_220118 _1020383_1283040, float* _1020384_1283041, float* _1020385_1283042, struct_Img_220118 _1020386_1283043, struct_Img_220118 _1020387_1283044) {
int _1283047;
int p_1283047;
int _1283050;
int p_1283050;
int _1283053;
int p_1283053;
int _1283056;
int p_1283056;
int _1283059;
int p_1283059;
int _1283062;
int p_1283062;
int _1283065;
int p_1283065;
struct_BoundaryMode_220129 bh_lower_1283072;
struct_BoundaryMode_220129 pbh_lower_1283072;
struct_BoundaryMode_220129 bh_upper_1283083;
struct_BoundaryMode_220129 pbh_upper_1283083;
float _1283100;
float p_1283100;
float _1283103;
float p_1283103;
struct_BoundaryMode_220129 bh_lower_1283107;
struct_BoundaryMode_220129 pbh_lower_1283107;
struct_BoundaryMode_220129 bh_upper_1283113;
struct_BoundaryMode_220129 pbh_upper_1283113;
float _1283129;
float p_1283129;
float _1283132;
float p_1283132;
struct_BoundaryMode_220129 bh_lower_1283138;
struct_BoundaryMode_220129 pbh_lower_1283138;
struct_BoundaryMode_220129 bh_upper_1283142;
struct_BoundaryMode_220129 pbh_upper_1283142;
float _1283158;
float p_1283158;
float _1283161;
float p_1283161;
struct_BoundaryMode_220129 bh_lower_1283167;
struct_BoundaryMode_220129 pbh_lower_1283167;
struct_BoundaryMode_220129 bh_upper_1283171;
struct_BoundaryMode_220129 pbh_upper_1283171;
float _1283187;
float p_1283187;
float _1283190;
float p_1283190;
struct_BoundaryMode_220129 bh_lower_1283194;
struct_BoundaryMode_220129 pbh_lower_1283194;
struct_BoundaryMode_220129 bh_upper_1283200;
struct_BoundaryMode_220129 pbh_upper_1283200;
float _1283216;
float p_1283216;
float _1283219;
float p_1283219;
_1283047 = threadIdx_x();
p_1283047 = _1283047;
l1283045: ;
_1283047 = p_1283047;
_1283050 = blockDim_x();
p_1283050 = _1283050;
l1283048: ;
_1283050 = p_1283050;
_1283053 = blockIdx_x();
p_1283053 = _1283053;
l1283051: ;
_1283053 = p_1283053;
_1283056 = threadIdx_y();
p_1283056 = _1283056;
l1283054: ;
_1283056 = p_1283056;
_1283059 = blockDim_y();
p_1283059 = _1283059;
l1283057: ;
_1283059 = p_1283059;
_1283062 = blockIdx_y();
p_1283062 = _1283062;
l1283060: ;
_1283062 = p_1283062;
_1283065 = blockDim_y();
p_1283065 = _1283065;
l1283063: ;
_1283065 = p_1283065;
int _1283066;
_1283066 = _1283050 * _1283053;
int gid_x_1283067;
gid_x_1283067 = _1283047 + _1283066;
union variant_220130 _1283256;
_1283256.qs32 = gid_x_1283067;
bool _1283068;
_1283068 = gid_x_1283067 < 0;
struct_BoundaryMode_220129 _1283257;
_1283257.e0 = 0;
_1283257.e1 = _1283256;
if (_1283068) goto l1283069; else goto l1283310;
l1283310: ;
pbh_lower_1283072 = _1283257;
goto l1283070;
l1283069: ;
union variant_220130 _1265919_5093;
_1265919_5093.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5095;
_1265920_5095.e0 = 1;
_1265920_5095.e1 = _1265919_5093;
pbh_lower_1283072 = _1265920_5095;
goto l1283070;
l1283070: ;
bh_lower_1283072 = pbh_lower_1283072;
int _1283073;
_1283073 = _1020386_1283043.e2;
int _1283074;
_1283074 = _1020383_1283040.e2;
int _1283077;
_1283077 = _1283059 * _1283062;
int _1283075;
_1283075 = _1283074 - 1;
int _1283076;
_1283076 = _1283075 + _1283056;
int gid_y_1283078;
gid_y_1283078 = _1283076 + _1283077;
union variant_220130 _1283268;
_1283268.qs32 = gid_y_1283078;
bool _1283079;
_1283079 = _1283073 <= gid_y_1283078;
struct_BoundaryMode_220129 _1283269;
_1283269.e0 = 0;
_1283269.e1 = _1283268;
if (_1283079) goto l1283080; else goto l1283309;
l1283309: ;
pbh_upper_1283083 = _1283269;
goto l1283081;
l1283080: ;
union variant_220130 _1265919_5105;
_1265919_5105.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5107;
_1265920_5107.e0 = 1;
_1265920_5107.e1 = _1265919_5105;
pbh_upper_1283083 = _1265920_5107;
goto l1283081;
l1283081: ;
bh_upper_1283083 = pbh_upper_1283083;
unsigned int _1283086;
_1283086 = bh_upper_1283083.e0;
unsigned int _1283084;
_1283084 = bh_lower_1283072.e0;
union variant_220130 _1283090;
_1283090 = bh_upper_1283083.e1;
int _1283092;
_1283092 = _1020386_1283043.e3;
union variant_220130 _1283094;
_1283094 = bh_lower_1283072.e1;
bool _1283087;
_1283087 = _1283086 == 0;
bool _1283085;
_1283085 = _1283084 == 0;
bool _1283088;
_1283088 = _1283085 & _1283087;
if (_1283088) goto l1283089; else goto l1283300;
l1283300: ;
bool _1283301;
_1283301 = _1283084 == 1;
if (_1283301) goto l1283302; else goto l1283304;
l1283304: ;
bool _1283305;
_1283305 = _1283086 == 1;
if (_1283305) goto l1283306; else goto l1283308;
l1283308: ;
// bottom: float r4_1265918_5120;
// bottom: p_1283103 = r4_1265918_5120;
goto l1283101;
l1283306: ;
float c_1283307;
c_1283307 = _1283090.pf32;
p_1283103 = c_1283307;
goto l1283101;
l1283302: ;
float c_1283303;
c_1283303 = _1283094.pf32;
p_1283103 = c_1283303;
goto l1283101;
l1283089: ;
int y_1283091;
y_1283091 = _1283090.qs32;
int x_1283095;
x_1283095 = _1283094.qs32;
int _1283093;
_1283093 = y_1283091 * _1283092;
int _1283096;
_1283096 = _1283093 + x_1283095;
float* idx_1283097;
idx_1283097 = _1020385_1283042 + _1283096;
_1283100 = __ldg(idx_1283097);
p_1283100 = _1283100;
l1283098: ;
_1283100 = p_1283100;
p_1283103 = _1283100;
goto l1283101;
l1283101: ;
_1283103 = p_1283103;
int _1283225;
_1283225 = _1020387_1283044.e3;
int _1283226;
_1283226 = gid_y_1283078 * _1283225;
int _1283227;
_1283227 = _1283226 + gid_x_1283067;
float* idx_1283228;
idx_1283228 = _1020382_1283039 + _1283227;
float _1283229;
_1283229 = *idx_1283228;
if (_1283068) goto l1283104; else goto l1283299;
l1283299: ;
pbh_lower_1283107 = _1283257;
goto l1283105;
l1283104: ;
union variant_220130 _1265919_5122;
_1265919_5122.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5124;
_1265920_5124.e0 = 1;
_1265920_5124.e1 = _1265919_5122;
pbh_lower_1283107 = _1265920_5124;
goto l1283105;
l1283105: ;
bh_lower_1283107 = pbh_lower_1283107;
int _1283108;
_1283108 = -1 + gid_y_1283078;
bool _1283109;
_1283109 = _1283073 <= _1283108;
if (_1283109) goto l1283110; else goto l1283295;
l1283295: ;
union variant_220130 _1283296;
_1283296.qs32 = _1283108;
struct_BoundaryMode_220129 _1283297;
_1283297.e0 = 0;
_1283297.e1 = _1283296;
pbh_upper_1283113 = _1283297;
goto l1283111;
l1283110: ;
union variant_220130 _1265919_5132;
_1265919_5132.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5134;
_1265920_5134.e0 = 1;
_1265920_5134.e1 = _1265919_5132;
pbh_upper_1283113 = _1265920_5134;
goto l1283111;
l1283111: ;
bh_upper_1283113 = pbh_upper_1283113;
unsigned int _1283114;
_1283114 = bh_lower_1283107.e0;
bool _1283115;
_1283115 = _1283114 == 0;
union variant_220130 _1283120;
_1283120 = bh_upper_1283113.e1;
unsigned int _1283116;
_1283116 = bh_upper_1283113.e0;
union variant_220130 _1283123;
_1283123 = bh_lower_1283107.e1;
bool _1283117;
_1283117 = _1283116 == 0;
bool _1283118;
_1283118 = _1283115 & _1283117;
if (_1283118) goto l1283119; else goto l1283286;
l1283286: ;
bool _1283287;
_1283287 = _1283114 == 1;
if (_1283287) goto l1283288; else goto l1283290;
l1283290: ;
bool _1283291;
_1283291 = _1283116 == 1;
if (_1283291) goto l1283292; else goto l1283294;
l1283294: ;
// bottom: float r4_1265918_5146;
// bottom: p_1283132 = r4_1265918_5146;
goto l1283130;
l1283292: ;
float c_1283293;
c_1283293 = _1283120.pf32;
p_1283132 = c_1283293;
goto l1283130;
l1283288: ;
float c_1283289;
c_1283289 = _1283123.pf32;
p_1283132 = c_1283289;
goto l1283130;
l1283119: ;
int y_1283121;
y_1283121 = _1283120.qs32;
int x_1283124;
x_1283124 = _1283123.qs32;
int _1283122;
_1283122 = y_1283121 * _1283092;
int _1283125;
_1283125 = _1283122 + x_1283124;
float* idx_1283126;
idx_1283126 = _1020385_1283042 + _1283125;
_1283129 = __ldg(idx_1283126);
p_1283129 = _1283129;
l1283127: ;
_1283129 = p_1283129;
p_1283132 = _1283129;
goto l1283130;
l1283130: ;
_1283132 = p_1283132;
int _1283133;
_1283133 = -1 + gid_x_1283067;
bool _1283134;
_1283134 = _1283133 < 0;
if (_1283134) goto l1283135; else goto l1283283;
l1283283: ;
union variant_220130 _1283284;
_1283284.qs32 = _1283133;
struct_BoundaryMode_220129 _1283285;
_1283285.e0 = 0;
_1283285.e1 = _1283284;
pbh_lower_1283138 = _1283285;
goto l1283136;
l1283135: ;
union variant_220130 _1265919_5152;
_1265919_5152.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5154;
_1265920_5154.e0 = 1;
_1265920_5154.e1 = _1265919_5152;
pbh_lower_1283138 = _1265920_5154;
goto l1283136;
l1283136: ;
bh_lower_1283138 = pbh_lower_1283138;
if (_1283079) goto l1283139; else goto l1283282;
l1283282: ;
pbh_upper_1283142 = _1283269;
goto l1283140;
l1283139: ;
union variant_220130 _1265919_5158;
_1265919_5158.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5160;
_1265920_5160.e0 = 1;
_1265920_5160.e1 = _1265919_5158;
pbh_upper_1283142 = _1265920_5160;
goto l1283140;
l1283140: ;
bh_upper_1283142 = pbh_upper_1283142;
union variant_220130 _1283152;
_1283152 = bh_lower_1283138.e1;
union variant_220130 _1283149;
_1283149 = bh_upper_1283142.e1;
unsigned int _1283143;
_1283143 = bh_lower_1283138.e0;
unsigned int _1283145;
_1283145 = bh_upper_1283142.e0;
bool _1283144;
_1283144 = _1283143 == 0;
bool _1283146;
_1283146 = _1283145 == 0;
bool _1283147;
_1283147 = _1283144 & _1283146;
if (_1283147) goto l1283148; else goto l1283273;
l1283273: ;
bool _1283274;
_1283274 = _1283143 == 1;
if (_1283274) goto l1283275; else goto l1283277;
l1283277: ;
bool _1283278;
_1283278 = _1283145 == 1;
if (_1283278) goto l1283279; else goto l1283281;
l1283281: ;
// bottom: float r4_1265918_5172;
// bottom: p_1283161 = r4_1265918_5172;
goto l1283159;
l1283279: ;
float c_1283280;
c_1283280 = _1283149.pf32;
p_1283161 = c_1283280;
goto l1283159;
l1283275: ;
float c_1283276;
c_1283276 = _1283152.pf32;
p_1283161 = c_1283276;
goto l1283159;
l1283148: ;
int x_1283153;
x_1283153 = _1283152.qs32;
int y_1283150;
y_1283150 = _1283149.qs32;
int _1283151;
_1283151 = y_1283150 * _1283092;
int _1283154;
_1283154 = _1283151 + x_1283153;
float* idx_1283155;
idx_1283155 = _1020385_1283042 + _1283154;
_1283158 = __ldg(idx_1283155);
p_1283158 = _1283158;
l1283156: ;
_1283158 = p_1283158;
p_1283161 = _1283158;
goto l1283159;
l1283159: ;
_1283161 = p_1283161;
int _1283162;
_1283162 = 1 + gid_x_1283067;
bool _1283163;
_1283163 = _1283162 < 0;
if (_1283163) goto l1283164; else goto l1283270;
l1283270: ;
union variant_220130 _1283271;
_1283271.qs32 = _1283162;
struct_BoundaryMode_220129 _1283272;
_1283272.e0 = 0;
_1283272.e1 = _1283271;
pbh_lower_1283167 = _1283272;
goto l1283165;
l1283164: ;
union variant_220130 _1265919_5178;
_1265919_5178.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5180;
_1265920_5180.e0 = 1;
_1265920_5180.e1 = _1265919_5178;
pbh_lower_1283167 = _1265920_5180;
goto l1283165;
l1283165: ;
bh_lower_1283167 = pbh_lower_1283167;
if (_1283079) goto l1283168; else goto l1283267;
l1283267: ;
pbh_upper_1283171 = _1283269;
goto l1283169;
l1283168: ;
union variant_220130 _1265919_5184;
_1265919_5184.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5186;
_1265920_5186.e0 = 1;
_1265920_5186.e1 = _1265919_5184;
pbh_upper_1283171 = _1265920_5186;
goto l1283169;
l1283169: ;
bh_upper_1283171 = pbh_upper_1283171;
unsigned int _1283172;
_1283172 = bh_lower_1283167.e0;
union variant_220130 _1283178;
_1283178 = bh_upper_1283171.e1;
bool _1283173;
_1283173 = _1283172 == 0;
union variant_220130 _1283181;
_1283181 = bh_lower_1283167.e1;
unsigned int _1283174;
_1283174 = bh_upper_1283171.e0;
bool _1283175;
_1283175 = _1283174 == 0;
bool _1283176;
_1283176 = _1283173 & _1283175;
if (_1283176) goto l1283177; else goto l1283258;
l1283258: ;
bool _1283259;
_1283259 = _1283172 == 1;
if (_1283259) goto l1283260; else goto l1283262;
l1283262: ;
bool _1283263;
_1283263 = _1283174 == 1;
if (_1283263) goto l1283264; else goto l1283266;
l1283266: ;
// bottom: float r4_1265918_5198;
// bottom: p_1283190 = r4_1265918_5198;
goto l1283188;
l1283264: ;
float c_1283265;
c_1283265 = _1283178.pf32;
p_1283190 = c_1283265;
goto l1283188;
l1283260: ;
float c_1283261;
c_1283261 = _1283181.pf32;
p_1283190 = c_1283261;
goto l1283188;
l1283177: ;
int x_1283182;
x_1283182 = _1283181.qs32;
int y_1283179;
y_1283179 = _1283178.qs32;
int _1283180;
_1283180 = y_1283179 * _1283092;
int _1283183;
_1283183 = _1283180 + x_1283182;
float* idx_1283184;
idx_1283184 = _1020385_1283042 + _1283183;
_1283187 = __ldg(idx_1283184);
p_1283187 = _1283187;
l1283185: ;
_1283187 = p_1283187;
p_1283190 = _1283187;
goto l1283188;
l1283188: ;
_1283190 = p_1283190;
if (_1283068) goto l1283191; else goto l1283255;
l1283255: ;
pbh_lower_1283194 = _1283257;
goto l1283192;
l1283191: ;
union variant_220130 _1265919_5199;
_1265919_5199.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5201;
_1265920_5201.e0 = 1;
_1265920_5201.e1 = _1265919_5199;
pbh_lower_1283194 = _1265920_5201;
goto l1283192;
l1283192: ;
bh_lower_1283194 = pbh_lower_1283194;
int _1283195;
_1283195 = 1 + gid_y_1283078;
bool _1283196;
_1283196 = _1283073 <= _1283195;
if (_1283196) goto l1283197; else goto l1283252;
l1283252: ;
union variant_220130 _1283253;
_1283253.qs32 = _1283195;
struct_BoundaryMode_220129 _1283254;
_1283254.e0 = 0;
_1283254.e1 = _1283253;
pbh_upper_1283200 = _1283254;
goto l1283198;
l1283197: ;
union variant_220130 _1265919_5209;
_1265919_5209.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5211;
_1265920_5211.e0 = 1;
_1265920_5211.e1 = _1265919_5209;
pbh_upper_1283200 = _1265920_5211;
goto l1283198;
l1283198: ;
bh_upper_1283200 = pbh_upper_1283200;
union variant_220130 _1283210;
_1283210 = bh_lower_1283194.e1;
union variant_220130 _1283207;
_1283207 = bh_upper_1283200.e1;
unsigned int _1283201;
_1283201 = bh_lower_1283194.e0;
unsigned int _1283203;
_1283203 = bh_upper_1283200.e0;
bool _1283202;
_1283202 = _1283201 == 0;
bool _1283204;
_1283204 = _1283203 == 0;
bool _1283205;
_1283205 = _1283202 & _1283204;
if (_1283205) goto l1283206; else goto l1283243;
l1283243: ;
bool _1283244;
_1283244 = _1283201 == 1;
if (_1283244) goto l1283245; else goto l1283247;
l1283247: ;
bool _1283248;
_1283248 = _1283203 == 1;
if (_1283248) goto l1283249; else goto l1283251;
l1283251: ;
// bottom: float r4_1265918_5223;
// bottom: p_1283219 = r4_1265918_5223;
goto l1283217;
l1283249: ;
float c_1283250;
c_1283250 = _1283207.pf32;
p_1283219 = c_1283250;
goto l1283217;
l1283245: ;
float c_1283246;
c_1283246 = _1283210.pf32;
p_1283219 = c_1283246;
goto l1283217;
l1283206: ;
int y_1283208;
y_1283208 = _1283207.qs32;
int x_1283211;
x_1283211 = _1283210.qs32;
int _1283209;
_1283209 = y_1283208 * _1283092;
int _1283212;
_1283212 = _1283209 + x_1283211;
float* idx_1283213;
idx_1283213 = _1020385_1283042 + _1283212;
_1283216 = __ldg(idx_1283213);
p_1283216 = _1283216;
l1283214: ;
_1283216 = p_1283216;
p_1283219 = _1283216;
goto l1283217;
l1283217: ;
_1283219 = p_1283219;
float _1283224;
_1283224 = 2.000000e-01f * _1283103;
float _1283237;
_1283237 = 2.500000e-01f * _1283190;
float _1283239;
_1283239 = 2.500000e-01f * _1283219;
int _1283220;
_1283220 = _1020383_1283040.e3;
float _1283230;
_1283230 = _1283229;
float _1283233;
_1283233 = 2.500000e-01f * _1283132;
float _1283235;
_1283235 = 2.500000e-01f * _1283161;
int _1283221;
_1283221 = gid_y_1283078 * _1283220;
float _1283234;
_1283234 = 0.000000e+00f + _1283233;
float _1283236;
_1283236 = _1283234 + _1283235;
float _1283238;
_1283238 = _1283236 + _1283237;
float _1283240;
_1283240 = _1283238 + _1283239;
float _1283231;
_1283231 = 2.000000e-01f * _1283230;
int _1283222;
_1283222 = _1283221 + gid_x_1283067;
float _1283232;
_1283232 = _1283224 + _1283231;
float* idx_1283223;
idx_1283223 = _1020384_1283041 + _1283222;
float val_1283241;
val_1283241 = _1283232 + _1283240;
*idx_1283223 = val_1283241;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1013003(struct_Img_220118 _1013006_1285197, struct_Img_220118 _1013007_1285198, float* _1013008_1285199, struct_Img_220118 _1013009_1285200, float* _1013010_1285201, float* _1013011_1285202) {
int _1285205;
int p_1285205;
int _1285208;
int p_1285208;
int _1285211;
int p_1285211;
int _1285214;
int p_1285214;
int _1285217;
int p_1285217;
int _1285220;
int p_1285220;
int _1285223;
int p_1285223;
struct_BoundaryMode_220129 bh_upper_1285234;
struct_BoundaryMode_220129 pbh_upper_1285234;
float _1285249;
float p_1285249;
float _1285252;
float p_1285252;
struct_BoundaryMode_220129 bh_upper_1285256;
struct_BoundaryMode_220129 pbh_upper_1285256;
float _1285267;
float p_1285267;
float _1285270;
float p_1285270;
struct_BoundaryMode_220129 bh_upper_1285276;
struct_BoundaryMode_220129 pbh_upper_1285276;
float _1285286;
float p_1285286;
float _1285289;
float p_1285289;
struct_BoundaryMode_220129 bh_upper_1285295;
struct_BoundaryMode_220129 pbh_upper_1285295;
float _1285305;
float p_1285305;
float _1285308;
float p_1285308;
struct_BoundaryMode_220129 bh_upper_1285312;
struct_BoundaryMode_220129 pbh_upper_1285312;
float _1285324;
float p_1285324;
float _1285327;
float p_1285327;
_1285205 = threadIdx_x();
p_1285205 = _1285205;
l1285203: ;
_1285205 = p_1285205;
_1285208 = blockDim_x();
p_1285208 = _1285208;
l1285206: ;
_1285208 = p_1285208;
_1285211 = blockIdx_x();
p_1285211 = _1285211;
l1285209: ;
_1285211 = p_1285211;
_1285214 = threadIdx_y();
p_1285214 = _1285214;
l1285212: ;
_1285214 = p_1285214;
_1285217 = blockDim_y();
p_1285217 = _1285217;
l1285215: ;
_1285217 = p_1285217;
_1285220 = blockIdx_y();
p_1285220 = _1285220;
l1285218: ;
_1285220 = p_1285220;
_1285223 = blockDim_y();
p_1285223 = _1285223;
l1285221: ;
_1285223 = p_1285223;
int _1285228;
_1285228 = _1285208 * _1285211;
int _1285225;
_1285225 = _1013009_1285200.e1;
int _1285224;
_1285224 = _1013006_1285197.e1;
int _1285226;
_1285226 = _1285225 - 128;
int _1285227;
_1285227 = _1285226 + _1285205;
int gid_x_1285229;
gid_x_1285229 = _1285227 + _1285228;
bool _1285230;
_1285230 = _1285224 <= gid_x_1285229;
union variant_220130 _1285357;
_1285357.qs32 = gid_x_1285229;
struct_BoundaryMode_220129 _1285358;
_1285358.e0 = 0;
_1285358.e1 = _1285357;
if (_1285230) goto l1285231; else goto l1285387;
l1285387: ;
pbh_upper_1285234 = _1285358;
goto l1285232;
l1285231: ;
union variant_220130 _1265919_5238;
_1265919_5238.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5240;
_1265920_5240.e0 = 1;
_1265920_5240.e1 = _1265919_5238;
pbh_upper_1285234 = _1265920_5240;
goto l1285232;
l1285232: ;
bh_upper_1285234 = pbh_upper_1285234;
union variant_220130 _1285243;
_1285243 = bh_upper_1285234.e1;
int _1285238;
_1285238 = _1285217 * _1285220;
int gid_y_1285239;
gid_y_1285239 = _1285214 + _1285238;
int _1285240;
_1285240 = 1 + gid_y_1285239;
int _1285241;
_1285241 = _1013006_1285197.e3;
unsigned int _1285235;
_1285235 = bh_upper_1285234.e0;
bool _1285236;
_1285236 = _1285235 == 0;
int _1285242;
_1285242 = _1285240 * _1285241;
if (_1285236) goto l1285237; else goto l1285382;
l1285382: ;
bool _1285383;
_1285383 = _1285235 == 1;
if (_1285383) goto l1285384; else goto l1285386;
l1285386: ;
// bottom: float r4_1265918_5250;
// bottom: p_1285252 = r4_1265918_5250;
goto l1285250;
l1285384: ;
float c_1285385;
c_1285385 = _1285243.pf32;
p_1285252 = c_1285385;
goto l1285250;
l1285237: ;
int x_1285244;
x_1285244 = _1285243.qs32;
int _1285245;
_1285245 = _1285242 + x_1285244;
float* idx_1285246;
idx_1285246 = _1013010_1285201 + _1285245;
_1285249 = __ldg(idx_1285246);
p_1285249 = _1285249;
l1285247: ;
_1285249 = p_1285249;
p_1285252 = _1285249;
goto l1285250;
l1285250: ;
_1285252 = p_1285252;
int _1285333;
_1285333 = _1013007_1285198.e3;
int _1285334;
_1285334 = _1285240 * _1285333;
int _1285335;
_1285335 = _1285334 + gid_x_1285229;
float* idx_1285336;
idx_1285336 = _1013011_1285202 + _1285335;
float _1285337;
_1285337 = *idx_1285336;
if (_1285230) goto l1285253; else goto l1285381;
l1285381: ;
pbh_upper_1285256 = _1285358;
goto l1285254;
l1285253: ;
union variant_220130 _1265919_5252;
_1265919_5252.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5254;
_1265920_5254.e0 = 1;
_1265920_5254.e1 = _1265919_5252;
pbh_upper_1285256 = _1265920_5254;
goto l1285254;
l1285254: ;
bh_upper_1285256 = pbh_upper_1285256;
unsigned int _1285257;
_1285257 = bh_upper_1285256.e0;
union variant_220130 _1285261;
_1285261 = bh_upper_1285256.e1;
bool _1285258;
_1285258 = _1285257 == 0;
if (_1285258) goto l1285259; else goto l1285375;
l1285375: ;
bool _1285376;
_1285376 = _1285257 == 1;
if (_1285376) goto l1285377; else goto l1285379;
l1285379: ;
// bottom: float r4_1265918_5262;
// bottom: p_1285270 = r4_1265918_5262;
goto l1285268;
l1285377: ;
float c_1285378;
c_1285378 = _1285261.pf32;
p_1285270 = c_1285378;
goto l1285268;
l1285259: ;
int _1285260;
_1285260 = gid_y_1285239 * _1285241;
int x_1285262;
x_1285262 = _1285261.qs32;
int _1285263;
_1285263 = _1285260 + x_1285262;
float* idx_1285264;
idx_1285264 = _1013010_1285201 + _1285263;
_1285267 = __ldg(idx_1285264);
p_1285267 = _1285267;
l1285265: ;
_1285267 = p_1285267;
p_1285270 = _1285267;
goto l1285268;
l1285268: ;
_1285270 = p_1285270;
int _1285271;
_1285271 = -1 + gid_x_1285229;
bool _1285272;
_1285272 = _1285224 <= _1285271;
if (_1285272) goto l1285273; else goto l1285372;
l1285372: ;
union variant_220130 _1285373;
_1285373.qs32 = _1285271;
struct_BoundaryMode_220129 _1285374;
_1285374.e0 = 0;
_1285374.e1 = _1285373;
pbh_upper_1285276 = _1285374;
goto l1285274;
l1285273: ;
union variant_220130 _1265919_5267;
_1265919_5267.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5269;
_1265920_5269.e0 = 1;
_1265920_5269.e1 = _1265919_5267;
pbh_upper_1285276 = _1265920_5269;
goto l1285274;
l1285274: ;
bh_upper_1285276 = pbh_upper_1285276;
unsigned int _1285277;
_1285277 = bh_upper_1285276.e0;
union variant_220130 _1285280;
_1285280 = bh_upper_1285276.e1;
bool _1285278;
_1285278 = _1285277 == 0;
if (_1285278) goto l1285279; else goto l1285367;
l1285367: ;
bool _1285368;
_1285368 = _1285277 == 1;
if (_1285368) goto l1285369; else goto l1285371;
l1285371: ;
// bottom: float r4_1265918_5277;
// bottom: p_1285289 = r4_1265918_5277;
goto l1285287;
l1285369: ;
float c_1285370;
c_1285370 = _1285280.pf32;
p_1285289 = c_1285370;
goto l1285287;
l1285279: ;
int x_1285281;
x_1285281 = _1285280.qs32;
int _1285282;
_1285282 = _1285242 + x_1285281;
float* idx_1285283;
idx_1285283 = _1013010_1285201 + _1285282;
_1285286 = __ldg(idx_1285283);
p_1285286 = _1285286;
l1285284: ;
_1285286 = p_1285286;
p_1285289 = _1285286;
goto l1285287;
l1285287: ;
_1285289 = p_1285289;
int _1285290;
_1285290 = 1 + gid_x_1285229;
bool _1285291;
_1285291 = _1285224 <= _1285290;
if (_1285291) goto l1285292; else goto l1285364;
l1285364: ;
union variant_220130 _1285365;
_1285365.qs32 = _1285290;
struct_BoundaryMode_220129 _1285366;
_1285366.e0 = 0;
_1285366.e1 = _1285365;
pbh_upper_1285295 = _1285366;
goto l1285293;
l1285292: ;
union variant_220130 _1265919_5282;
_1265919_5282.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5284;
_1265920_5284.e0 = 1;
_1265920_5284.e1 = _1265919_5282;
pbh_upper_1285295 = _1265920_5284;
goto l1285293;
l1285293: ;
bh_upper_1285295 = pbh_upper_1285295;
union variant_220130 _1285299;
_1285299 = bh_upper_1285295.e1;
unsigned int _1285296;
_1285296 = bh_upper_1285295.e0;
bool _1285297;
_1285297 = _1285296 == 0;
if (_1285297) goto l1285298; else goto l1285359;
l1285359: ;
bool _1285360;
_1285360 = _1285296 == 1;
if (_1285360) goto l1285361; else goto l1285363;
l1285363: ;
// bottom: float r4_1265918_5292;
// bottom: p_1285308 = r4_1265918_5292;
goto l1285306;
l1285361: ;
float c_1285362;
c_1285362 = _1285299.pf32;
p_1285308 = c_1285362;
goto l1285306;
l1285298: ;
int x_1285300;
x_1285300 = _1285299.qs32;
int _1285301;
_1285301 = _1285242 + x_1285300;
float* idx_1285302;
idx_1285302 = _1013010_1285201 + _1285301;
_1285305 = __ldg(idx_1285302);
p_1285305 = _1285305;
l1285303: ;
_1285305 = p_1285305;
p_1285308 = _1285305;
goto l1285306;
l1285306: ;
_1285308 = p_1285308;
if (_1285230) goto l1285309; else goto l1285356;
l1285356: ;
pbh_upper_1285312 = _1285358;
goto l1285310;
l1285309: ;
union variant_220130 _1265919_5293;
_1265919_5293.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5295;
_1265920_5295.e0 = 1;
_1265920_5295.e1 = _1265919_5293;
pbh_upper_1285312 = _1265920_5295;
goto l1285310;
l1285310: ;
bh_upper_1285312 = pbh_upper_1285312;
union variant_220130 _1285318;
_1285318 = bh_upper_1285312.e1;
unsigned int _1285313;
_1285313 = bh_upper_1285312.e0;
bool _1285314;
_1285314 = _1285313 == 0;
if (_1285314) goto l1285315; else goto l1285351;
l1285351: ;
bool _1285352;
_1285352 = _1285313 == 1;
if (_1285352) goto l1285353; else goto l1285355;
l1285355: ;
// bottom: float r4_1265918_5303;
// bottom: p_1285327 = r4_1265918_5303;
goto l1285325;
l1285353: ;
float c_1285354;
c_1285354 = _1285318.pf32;
p_1285327 = c_1285354;
goto l1285325;
l1285315: ;
int _1285316;
_1285316 = 2 + gid_y_1285239;
int x_1285319;
x_1285319 = _1285318.qs32;
int _1285317;
_1285317 = _1285316 * _1285241;
int _1285320;
_1285320 = _1285317 + x_1285319;
float* idx_1285321;
idx_1285321 = _1013010_1285201 + _1285320;
_1285324 = __ldg(idx_1285321);
p_1285324 = _1285324;
l1285322: ;
_1285324 = p_1285324;
p_1285327 = _1285324;
goto l1285325;
l1285325: ;
_1285327 = p_1285327;
float _1285345;
_1285345 = 2.500000e-01f * _1285308;
float _1285347;
_1285347 = 2.500000e-01f * _1285327;
float _1285332;
_1285332 = 2.000000e-01f * _1285252;
float _1285343;
_1285343 = 2.500000e-01f * _1285289;
float _1285341;
_1285341 = 2.500000e-01f * _1285270;
int _1285328;
_1285328 = _1013009_1285200.e3;
int _1285329;
_1285329 = _1285240 * _1285328;
float _1285338;
_1285338 = _1285337;
float _1285342;
_1285342 = 0.000000e+00f + _1285341;
int _1285330;
_1285330 = _1285329 + gid_x_1285229;
float _1285339;
_1285339 = 2.000000e-01f * _1285338;
float _1285344;
_1285344 = _1285342 + _1285343;
float* idx_1285331;
idx_1285331 = _1013008_1285199 + _1285330;
float _1285340;
_1285340 = _1285332 + _1285339;
float _1285346;
_1285346 = _1285344 + _1285345;
float _1285348;
_1285348 = _1285346 + _1285347;
float val_1285349;
val_1285349 = _1285340 + _1285348;
*idx_1285331 = val_1285349;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1005286(struct_Img_220118 _1005289_1274393, struct_Img_220118 _1005290_1274394, float* _1005291_1274395, struct_Img_220118 _1005292_1274396, float* _1005293_1274397, float* _1005294_1274398) {
int _1274401;
int p_1274401;
int _1274404;
int p_1274404;
int _1274407;
int p_1274407;
int _1274410;
int p_1274410;
int _1274413;
int p_1274413;
int _1274416;
int p_1274416;
int _1274419;
int p_1274419;
struct_BoundaryMode_220129 bh_lower_1274426;
struct_BoundaryMode_220129 pbh_lower_1274426;
struct_BoundaryMode_220129 bh_upper_1274437;
struct_BoundaryMode_220129 pbh_upper_1274437;
float _1274454;
float p_1274454;
float _1274457;
float p_1274457;
struct_BoundaryMode_220129 bh_lower_1274461;
struct_BoundaryMode_220129 pbh_lower_1274461;
struct_BoundaryMode_220129 bh_upper_1274467;
struct_BoundaryMode_220129 pbh_upper_1274467;
float _1274483;
float p_1274483;
float _1274486;
float p_1274486;
struct_BoundaryMode_220129 bh_lower_1274492;
struct_BoundaryMode_220129 pbh_lower_1274492;
struct_BoundaryMode_220129 bh_upper_1274496;
struct_BoundaryMode_220129 pbh_upper_1274496;
float _1274512;
float p_1274512;
float _1274515;
float p_1274515;
struct_BoundaryMode_220129 bh_lower_1274521;
struct_BoundaryMode_220129 pbh_lower_1274521;
struct_BoundaryMode_220129 bh_upper_1274525;
struct_BoundaryMode_220129 pbh_upper_1274525;
float _1274541;
float p_1274541;
float _1274544;
float p_1274544;
struct_BoundaryMode_220129 bh_lower_1274548;
struct_BoundaryMode_220129 pbh_lower_1274548;
struct_BoundaryMode_220129 bh_upper_1274554;
struct_BoundaryMode_220129 pbh_upper_1274554;
float _1274570;
float p_1274570;
float _1274573;
float p_1274573;
_1274401 = threadIdx_x();
p_1274401 = _1274401;
l1274399: ;
_1274401 = p_1274401;
_1274404 = blockDim_x();
p_1274404 = _1274404;
l1274402: ;
_1274404 = p_1274404;
_1274407 = blockIdx_x();
p_1274407 = _1274407;
l1274405: ;
_1274407 = p_1274407;
_1274410 = threadIdx_y();
p_1274410 = _1274410;
l1274408: ;
_1274410 = p_1274410;
_1274413 = blockDim_y();
p_1274413 = _1274413;
l1274411: ;
_1274413 = p_1274413;
_1274416 = blockIdx_y();
p_1274416 = _1274416;
l1274414: ;
_1274416 = p_1274416;
_1274419 = blockDim_y();
p_1274419 = _1274419;
l1274417: ;
_1274419 = p_1274419;
int _1274420;
_1274420 = _1274404 * _1274407;
int gid_x_1274421;
gid_x_1274421 = _1274401 + _1274420;
bool _1274422;
_1274422 = gid_x_1274421 < 0;
union variant_220130 _1274610;
_1274610.qs32 = gid_x_1274421;
struct_BoundaryMode_220129 _1274611;
_1274611.e0 = 0;
_1274611.e1 = _1274610;
if (_1274422) goto l1274423; else goto l1274664;
l1274664: ;
pbh_lower_1274426 = _1274611;
goto l1274424;
l1274423: ;
union variant_220130 _1265919_5317;
_1265919_5317.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5319;
_1265920_5319.e0 = 1;
_1265920_5319.e1 = _1265919_5317;
pbh_lower_1274426 = _1265920_5319;
goto l1274424;
l1274424: ;
bh_lower_1274426 = pbh_lower_1274426;
int _1274428;
_1274428 = _1005289_1274393.e2;
int _1274431;
_1274431 = _1274413 * _1274416;
int _1274427;
_1274427 = _1005290_1274394.e2;
int _1274429;
_1274429 = _1274428 - 1;
int _1274430;
_1274430 = _1274429 + _1274410;
int gid_y_1274432;
gid_y_1274432 = _1274430 + _1274431;
union variant_220130 _1274622;
_1274622.qs32 = gid_y_1274432;
bool _1274433;
_1274433 = _1274427 <= gid_y_1274432;
struct_BoundaryMode_220129 _1274623;
_1274623.e0 = 0;
_1274623.e1 = _1274622;
if (_1274433) goto l1274434; else goto l1274663;
l1274663: ;
pbh_upper_1274437 = _1274623;
goto l1274435;
l1274434: ;
union variant_220130 _1265919_5329;
_1265919_5329.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5331;
_1265920_5331.e0 = 1;
_1265920_5331.e1 = _1265919_5329;
pbh_upper_1274437 = _1265920_5331;
goto l1274435;
l1274435: ;
bh_upper_1274437 = pbh_upper_1274437;
int _1274446;
_1274446 = _1005290_1274394.e3;
unsigned int _1274438;
_1274438 = bh_lower_1274426.e0;
union variant_220130 _1274448;
_1274448 = bh_lower_1274426.e1;
bool _1274439;
_1274439 = _1274438 == 0;
unsigned int _1274440;
_1274440 = bh_upper_1274437.e0;
union variant_220130 _1274444;
_1274444 = bh_upper_1274437.e1;
bool _1274441;
_1274441 = _1274440 == 0;
bool _1274442;
_1274442 = _1274439 & _1274441;
if (_1274442) goto l1274443; else goto l1274654;
l1274654: ;
bool _1274655;
_1274655 = _1274438 == 1;
if (_1274655) goto l1274656; else goto l1274658;
l1274658: ;
bool _1274659;
_1274659 = _1274440 == 1;
if (_1274659) goto l1274660; else goto l1274662;
l1274662: ;
// bottom: float r4_1265918_5344;
// bottom: p_1274457 = r4_1265918_5344;
goto l1274455;
l1274660: ;
float c_1274661;
c_1274661 = _1274444.pf32;
p_1274457 = c_1274661;
goto l1274455;
l1274656: ;
float c_1274657;
c_1274657 = _1274448.pf32;
p_1274457 = c_1274657;
goto l1274455;
l1274443: ;
int x_1274449;
x_1274449 = _1274448.qs32;
int y_1274445;
y_1274445 = _1274444.qs32;
int _1274447;
_1274447 = y_1274445 * _1274446;
int _1274450;
_1274450 = _1274447 + x_1274449;
float* idx_1274451;
idx_1274451 = _1005291_1274395 + _1274450;
_1274454 = __ldg(idx_1274451);
p_1274454 = _1274454;
l1274452: ;
_1274454 = p_1274454;
p_1274457 = _1274454;
goto l1274455;
l1274455: ;
_1274457 = p_1274457;
int _1274579;
_1274579 = _1005292_1274396.e3;
int _1274580;
_1274580 = gid_y_1274432 * _1274579;
int _1274581;
_1274581 = _1274580 + gid_x_1274421;
float* idx_1274582;
idx_1274582 = _1005294_1274398 + _1274581;
float _1274583;
_1274583 = *idx_1274582;
if (_1274422) goto l1274458; else goto l1274653;
l1274653: ;
pbh_lower_1274461 = _1274611;
goto l1274459;
l1274458: ;
union variant_220130 _1265919_5346;
_1265919_5346.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5348;
_1265920_5348.e0 = 1;
_1265920_5348.e1 = _1265919_5346;
pbh_lower_1274461 = _1265920_5348;
goto l1274459;
l1274459: ;
bh_lower_1274461 = pbh_lower_1274461;
int _1274462;
_1274462 = -1 + gid_y_1274432;
bool _1274463;
_1274463 = _1274427 <= _1274462;
if (_1274463) goto l1274464; else goto l1274649;
l1274649: ;
union variant_220130 _1274650;
_1274650.qs32 = _1274462;
struct_BoundaryMode_220129 _1274651;
_1274651.e0 = 0;
_1274651.e1 = _1274650;
pbh_upper_1274467 = _1274651;
goto l1274465;
l1274464: ;
union variant_220130 _1265919_5356;
_1265919_5356.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5358;
_1265920_5358.e0 = 1;
_1265920_5358.e1 = _1265919_5356;
pbh_upper_1274467 = _1265920_5358;
goto l1274465;
l1274465: ;
bh_upper_1274467 = pbh_upper_1274467;
unsigned int _1274470;
_1274470 = bh_upper_1274467.e0;
unsigned int _1274468;
_1274468 = bh_lower_1274461.e0;
bool _1274469;
_1274469 = _1274468 == 0;
union variant_220130 _1274474;
_1274474 = bh_upper_1274467.e1;
bool _1274471;
_1274471 = _1274470 == 0;
union variant_220130 _1274477;
_1274477 = bh_lower_1274461.e1;
bool _1274472;
_1274472 = _1274469 & _1274471;
if (_1274472) goto l1274473; else goto l1274640;
l1274640: ;
bool _1274641;
_1274641 = _1274468 == 1;
if (_1274641) goto l1274642; else goto l1274644;
l1274644: ;
bool _1274645;
_1274645 = _1274470 == 1;
if (_1274645) goto l1274646; else goto l1274648;
l1274648: ;
// bottom: float r4_1265918_5370;
// bottom: p_1274486 = r4_1265918_5370;
goto l1274484;
l1274646: ;
float c_1274647;
c_1274647 = _1274474.pf32;
p_1274486 = c_1274647;
goto l1274484;
l1274642: ;
float c_1274643;
c_1274643 = _1274477.pf32;
p_1274486 = c_1274643;
goto l1274484;
l1274473: ;
int y_1274475;
y_1274475 = _1274474.qs32;
int x_1274478;
x_1274478 = _1274477.qs32;
int _1274476;
_1274476 = y_1274475 * _1274446;
int _1274479;
_1274479 = _1274476 + x_1274478;
float* idx_1274480;
idx_1274480 = _1005291_1274395 + _1274479;
_1274483 = __ldg(idx_1274480);
p_1274483 = _1274483;
l1274481: ;
_1274483 = p_1274483;
p_1274486 = _1274483;
goto l1274484;
l1274484: ;
_1274486 = p_1274486;
int _1274487;
_1274487 = -1 + gid_x_1274421;
bool _1274488;
_1274488 = _1274487 < 0;
if (_1274488) goto l1274489; else goto l1274637;
l1274637: ;
union variant_220130 _1274638;
_1274638.qs32 = _1274487;
struct_BoundaryMode_220129 _1274639;
_1274639.e0 = 0;
_1274639.e1 = _1274638;
pbh_lower_1274492 = _1274639;
goto l1274490;
l1274489: ;
union variant_220130 _1265919_5376;
_1265919_5376.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5378;
_1265920_5378.e0 = 1;
_1265920_5378.e1 = _1265919_5376;
pbh_lower_1274492 = _1265920_5378;
goto l1274490;
l1274490: ;
bh_lower_1274492 = pbh_lower_1274492;
if (_1274433) goto l1274493; else goto l1274636;
l1274636: ;
pbh_upper_1274496 = _1274623;
goto l1274494;
l1274493: ;
union variant_220130 _1265919_5382;
_1265919_5382.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5384;
_1265920_5384.e0 = 1;
_1265920_5384.e1 = _1265919_5382;
pbh_upper_1274496 = _1265920_5384;
goto l1274494;
l1274494: ;
bh_upper_1274496 = pbh_upper_1274496;
union variant_220130 _1274503;
_1274503 = bh_upper_1274496.e1;
unsigned int _1274499;
_1274499 = bh_upper_1274496.e0;
unsigned int _1274497;
_1274497 = bh_lower_1274492.e0;
bool _1274498;
_1274498 = _1274497 == 0;
union variant_220130 _1274506;
_1274506 = bh_lower_1274492.e1;
bool _1274500;
_1274500 = _1274499 == 0;
bool _1274501;
_1274501 = _1274498 & _1274500;
if (_1274501) goto l1274502; else goto l1274627;
l1274627: ;
bool _1274628;
_1274628 = _1274497 == 1;
if (_1274628) goto l1274629; else goto l1274631;
l1274631: ;
bool _1274632;
_1274632 = _1274499 == 1;
if (_1274632) goto l1274633; else goto l1274635;
l1274635: ;
// bottom: float r4_1265918_5396;
// bottom: p_1274515 = r4_1265918_5396;
goto l1274513;
l1274633: ;
float c_1274634;
c_1274634 = _1274503.pf32;
p_1274515 = c_1274634;
goto l1274513;
l1274629: ;
float c_1274630;
c_1274630 = _1274506.pf32;
p_1274515 = c_1274630;
goto l1274513;
l1274502: ;
int y_1274504;
y_1274504 = _1274503.qs32;
int x_1274507;
x_1274507 = _1274506.qs32;
int _1274505;
_1274505 = y_1274504 * _1274446;
int _1274508;
_1274508 = _1274505 + x_1274507;
float* idx_1274509;
idx_1274509 = _1005291_1274395 + _1274508;
_1274512 = __ldg(idx_1274509);
p_1274512 = _1274512;
l1274510: ;
_1274512 = p_1274512;
p_1274515 = _1274512;
goto l1274513;
l1274513: ;
_1274515 = p_1274515;
int _1274516;
_1274516 = 1 + gid_x_1274421;
bool _1274517;
_1274517 = _1274516 < 0;
if (_1274517) goto l1274518; else goto l1274624;
l1274624: ;
union variant_220130 _1274625;
_1274625.qs32 = _1274516;
struct_BoundaryMode_220129 _1274626;
_1274626.e0 = 0;
_1274626.e1 = _1274625;
pbh_lower_1274521 = _1274626;
goto l1274519;
l1274518: ;
union variant_220130 _1265919_5402;
_1265919_5402.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5404;
_1265920_5404.e0 = 1;
_1265920_5404.e1 = _1265919_5402;
pbh_lower_1274521 = _1265920_5404;
goto l1274519;
l1274519: ;
bh_lower_1274521 = pbh_lower_1274521;
if (_1274433) goto l1274522; else goto l1274621;
l1274621: ;
pbh_upper_1274525 = _1274623;
goto l1274523;
l1274522: ;
union variant_220130 _1265919_5408;
_1265919_5408.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5410;
_1265920_5410.e0 = 1;
_1265920_5410.e1 = _1265919_5408;
pbh_upper_1274525 = _1265920_5410;
goto l1274523;
l1274523: ;
bh_upper_1274525 = pbh_upper_1274525;
union variant_220130 _1274532;
_1274532 = bh_upper_1274525.e1;
union variant_220130 _1274535;
_1274535 = bh_lower_1274521.e1;
unsigned int _1274528;
_1274528 = bh_upper_1274525.e0;
bool _1274529;
_1274529 = _1274528 == 0;
unsigned int _1274526;
_1274526 = bh_lower_1274521.e0;
bool _1274527;
_1274527 = _1274526 == 0;
bool _1274530;
_1274530 = _1274527 & _1274529;
if (_1274530) goto l1274531; else goto l1274612;
l1274612: ;
bool _1274613;
_1274613 = _1274526 == 1;
if (_1274613) goto l1274614; else goto l1274616;
l1274616: ;
bool _1274617;
_1274617 = _1274528 == 1;
if (_1274617) goto l1274618; else goto l1274620;
l1274620: ;
// bottom: float r4_1265918_5422;
// bottom: p_1274544 = r4_1265918_5422;
goto l1274542;
l1274618: ;
float c_1274619;
c_1274619 = _1274532.pf32;
p_1274544 = c_1274619;
goto l1274542;
l1274614: ;
float c_1274615;
c_1274615 = _1274535.pf32;
p_1274544 = c_1274615;
goto l1274542;
l1274531: ;
int x_1274536;
x_1274536 = _1274535.qs32;
int y_1274533;
y_1274533 = _1274532.qs32;
int _1274534;
_1274534 = y_1274533 * _1274446;
int _1274537;
_1274537 = _1274534 + x_1274536;
float* idx_1274538;
idx_1274538 = _1005291_1274395 + _1274537;
_1274541 = __ldg(idx_1274538);
p_1274541 = _1274541;
l1274539: ;
_1274541 = p_1274541;
p_1274544 = _1274541;
goto l1274542;
l1274542: ;
_1274544 = p_1274544;
if (_1274422) goto l1274545; else goto l1274609;
l1274609: ;
pbh_lower_1274548 = _1274611;
goto l1274546;
l1274545: ;
union variant_220130 _1265919_5423;
_1265919_5423.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5425;
_1265920_5425.e0 = 1;
_1265920_5425.e1 = _1265919_5423;
pbh_lower_1274548 = _1265920_5425;
goto l1274546;
l1274546: ;
bh_lower_1274548 = pbh_lower_1274548;
int _1274549;
_1274549 = 1 + gid_y_1274432;
bool _1274550;
_1274550 = _1274427 <= _1274549;
if (_1274550) goto l1274551; else goto l1274606;
l1274606: ;
union variant_220130 _1274607;
_1274607.qs32 = _1274549;
struct_BoundaryMode_220129 _1274608;
_1274608.e0 = 0;
_1274608.e1 = _1274607;
pbh_upper_1274554 = _1274608;
goto l1274552;
l1274551: ;
union variant_220130 _1265919_5433;
_1265919_5433.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5435;
_1265920_5435.e0 = 1;
_1265920_5435.e1 = _1265919_5433;
pbh_upper_1274554 = _1265920_5435;
goto l1274552;
l1274552: ;
bh_upper_1274554 = pbh_upper_1274554;
union variant_220130 _1274564;
_1274564 = bh_lower_1274548.e1;
union variant_220130 _1274561;
_1274561 = bh_upper_1274554.e1;
unsigned int _1274555;
_1274555 = bh_lower_1274548.e0;
unsigned int _1274557;
_1274557 = bh_upper_1274554.e0;
bool _1274556;
_1274556 = _1274555 == 0;
bool _1274558;
_1274558 = _1274557 == 0;
bool _1274559;
_1274559 = _1274556 & _1274558;
if (_1274559) goto l1274560; else goto l1274597;
l1274597: ;
bool _1274598;
_1274598 = _1274555 == 1;
if (_1274598) goto l1274599; else goto l1274601;
l1274601: ;
bool _1274602;
_1274602 = _1274557 == 1;
if (_1274602) goto l1274603; else goto l1274605;
l1274605: ;
// bottom: float r4_1265918_5447;
// bottom: p_1274573 = r4_1265918_5447;
goto l1274571;
l1274603: ;
float c_1274604;
c_1274604 = _1274561.pf32;
p_1274573 = c_1274604;
goto l1274571;
l1274599: ;
float c_1274600;
c_1274600 = _1274564.pf32;
p_1274573 = c_1274600;
goto l1274571;
l1274560: ;
int x_1274565;
x_1274565 = _1274564.qs32;
int y_1274562;
y_1274562 = _1274561.qs32;
int _1274563;
_1274563 = y_1274562 * _1274446;
int _1274566;
_1274566 = _1274563 + x_1274565;
float* idx_1274567;
idx_1274567 = _1005291_1274395 + _1274566;
_1274570 = __ldg(idx_1274567);
p_1274570 = _1274570;
l1274568: ;
_1274570 = p_1274570;
p_1274573 = _1274570;
goto l1274571;
l1274571: ;
_1274573 = p_1274573;
float _1274591;
_1274591 = 2.500000e-01f * _1274544;
float _1274589;
_1274589 = 2.500000e-01f * _1274515;
float _1274584;
_1274584 = _1274583;
int _1274574;
_1274574 = _1005289_1274393.e3;
float _1274593;
_1274593 = 2.500000e-01f * _1274573;
float _1274578;
_1274578 = 2.000000e-01f * _1274457;
float _1274587;
_1274587 = 2.500000e-01f * _1274486;
float _1274585;
_1274585 = 2.000000e-01f * _1274584;
int _1274575;
_1274575 = gid_y_1274432 * _1274574;
float _1274586;
_1274586 = _1274578 + _1274585;
float _1274588;
_1274588 = 0.000000e+00f + _1274587;
int _1274576;
_1274576 = _1274575 + gid_x_1274421;
float _1274590;
_1274590 = _1274588 + _1274589;
float* idx_1274577;
idx_1274577 = _1005293_1274397 + _1274576;
float _1274592;
_1274592 = _1274590 + _1274591;
float _1274594;
_1274594 = _1274592 + _1274593;
float val_1274595;
val_1274595 = _1274586 + _1274594;
*idx_1274577 = val_1274595;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1000846(struct_Img_220118 _1000849_1270796, float* _1000850_1270797, struct_Img_220118 _1000851_1270798, float* _1000852_1270799, float* _1000853_1270800, struct_Img_220118 _1000854_1270801) {
int _1270804;
int p_1270804;
int _1270807;
int p_1270807;
int _1270810;
int p_1270810;
int _1270813;
int p_1270813;
int _1270816;
int p_1270816;
int _1270819;
int p_1270819;
int _1270822;
int p_1270822;
struct_BoundaryMode_220129 bh_lower_1270829;
struct_BoundaryMode_220129 pbh_lower_1270829;
struct_BoundaryMode_220129 bh_upper_1270840;
struct_BoundaryMode_220129 pbh_upper_1270840;
float _1270857;
float p_1270857;
float _1270860;
float p_1270860;
struct_BoundaryMode_220129 bh_lower_1270864;
struct_BoundaryMode_220129 pbh_lower_1270864;
struct_BoundaryMode_220129 bh_upper_1270870;
struct_BoundaryMode_220129 pbh_upper_1270870;
float _1270886;
float p_1270886;
float _1270889;
float p_1270889;
struct_BoundaryMode_220129 bh_lower_1270895;
struct_BoundaryMode_220129 pbh_lower_1270895;
struct_BoundaryMode_220129 bh_upper_1270899;
struct_BoundaryMode_220129 pbh_upper_1270899;
float _1270915;
float p_1270915;
float _1270918;
float p_1270918;
struct_BoundaryMode_220129 bh_lower_1270924;
struct_BoundaryMode_220129 pbh_lower_1270924;
struct_BoundaryMode_220129 bh_upper_1270928;
struct_BoundaryMode_220129 pbh_upper_1270928;
float _1270944;
float p_1270944;
float _1270947;
float p_1270947;
struct_BoundaryMode_220129 bh_lower_1270951;
struct_BoundaryMode_220129 pbh_lower_1270951;
struct_BoundaryMode_220129 bh_upper_1270957;
struct_BoundaryMode_220129 pbh_upper_1270957;
float _1270973;
float p_1270973;
float _1270976;
float p_1270976;
_1270804 = threadIdx_x();
p_1270804 = _1270804;
l1270802: ;
_1270804 = p_1270804;
_1270807 = blockDim_x();
p_1270807 = _1270807;
l1270805: ;
_1270807 = p_1270807;
_1270810 = blockIdx_x();
p_1270810 = _1270810;
l1270808: ;
_1270810 = p_1270810;
_1270813 = threadIdx_y();
p_1270813 = _1270813;
l1270811: ;
_1270813 = p_1270813;
_1270816 = blockDim_y();
p_1270816 = _1270816;
l1270814: ;
_1270816 = p_1270816;
_1270819 = blockIdx_y();
p_1270819 = _1270819;
l1270817: ;
_1270819 = p_1270819;
_1270822 = blockDim_y();
p_1270822 = _1270822;
l1270820: ;
_1270822 = p_1270822;
int _1270823;
_1270823 = _1270807 * _1270810;
int gid_x_1270824;
gid_x_1270824 = _1270804 + _1270823;
bool _1270825;
_1270825 = gid_x_1270824 < 0;
union variant_220130 _1271013;
_1271013.qs32 = gid_x_1270824;
struct_BoundaryMode_220129 _1271014;
_1271014.e0 = 0;
_1271014.e1 = _1271013;
if (_1270825) goto l1270826; else goto l1271067;
l1271067: ;
pbh_lower_1270829 = _1271014;
goto l1270827;
l1270826: ;
union variant_220130 _1265919_5460;
_1265919_5460.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5462;
_1265920_5462.e0 = 1;
_1265920_5462.e1 = _1265919_5460;
pbh_lower_1270829 = _1265920_5462;
goto l1270827;
l1270827: ;
bh_lower_1270829 = pbh_lower_1270829;
int _1270831;
_1270831 = _1000854_1270801.e2;
int _1270832;
_1270832 = _1270831 - 1;
int _1270830;
_1270830 = _1000849_1270796.e2;
int _1270834;
_1270834 = _1270816 * _1270819;
int _1270833;
_1270833 = _1270832 + _1270813;
int gid_y_1270835;
gid_y_1270835 = _1270833 + _1270834;
bool _1270836;
_1270836 = _1270830 <= gid_y_1270835;
union variant_220130 _1271025;
_1271025.qs32 = gid_y_1270835;
struct_BoundaryMode_220129 _1271026;
_1271026.e0 = 0;
_1271026.e1 = _1271025;
if (_1270836) goto l1270837; else goto l1271066;
l1271066: ;
pbh_upper_1270840 = _1271026;
goto l1270838;
l1270837: ;
union variant_220130 _1265919_5472;
_1265919_5472.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5474;
_1265920_5474.e0 = 1;
_1265920_5474.e1 = _1265919_5472;
pbh_upper_1270840 = _1265920_5474;
goto l1270838;
l1270838: ;
bh_upper_1270840 = pbh_upper_1270840;
int _1270849;
_1270849 = _1000849_1270796.e3;
union variant_220130 _1270851;
_1270851 = bh_lower_1270829.e1;
unsigned int _1270841;
_1270841 = bh_lower_1270829.e0;
union variant_220130 _1270847;
_1270847 = bh_upper_1270840.e1;
unsigned int _1270843;
_1270843 = bh_upper_1270840.e0;
bool _1270842;
_1270842 = _1270841 == 0;
bool _1270844;
_1270844 = _1270843 == 0;
bool _1270845;
_1270845 = _1270842 & _1270844;
if (_1270845) goto l1270846; else goto l1271057;
l1271057: ;
bool _1271058;
_1271058 = _1270841 == 1;
if (_1271058) goto l1271059; else goto l1271061;
l1271061: ;
bool _1271062;
_1271062 = _1270843 == 1;
if (_1271062) goto l1271063; else goto l1271065;
l1271065: ;
// bottom: float r4_1265918_5487;
// bottom: p_1270860 = r4_1265918_5487;
goto l1270858;
l1271063: ;
float c_1271064;
c_1271064 = _1270847.pf32;
p_1270860 = c_1271064;
goto l1270858;
l1271059: ;
float c_1271060;
c_1271060 = _1270851.pf32;
p_1270860 = c_1271060;
goto l1270858;
l1270846: ;
int x_1270852;
x_1270852 = _1270851.qs32;
int y_1270848;
y_1270848 = _1270847.qs32;
int _1270850;
_1270850 = y_1270848 * _1270849;
int _1270853;
_1270853 = _1270850 + x_1270852;
float* idx_1270854;
idx_1270854 = _1000850_1270797 + _1270853;
_1270857 = __ldg(idx_1270854);
p_1270857 = _1270857;
l1270855: ;
_1270857 = p_1270857;
p_1270860 = _1270857;
goto l1270858;
l1270858: ;
_1270860 = p_1270860;
int _1270982;
_1270982 = _1000851_1270798.e3;
int _1270983;
_1270983 = gid_y_1270835 * _1270982;
int _1270984;
_1270984 = _1270983 + gid_x_1270824;
float* idx_1270985;
idx_1270985 = _1000853_1270800 + _1270984;
float _1270986;
_1270986 = *idx_1270985;
if (_1270825) goto l1270861; else goto l1271056;
l1271056: ;
pbh_lower_1270864 = _1271014;
goto l1270862;
l1270861: ;
union variant_220130 _1265919_5489;
_1265919_5489.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5491;
_1265920_5491.e0 = 1;
_1265920_5491.e1 = _1265919_5489;
pbh_lower_1270864 = _1265920_5491;
goto l1270862;
l1270862: ;
bh_lower_1270864 = pbh_lower_1270864;
int _1270865;
_1270865 = -1 + gid_y_1270835;
bool _1270866;
_1270866 = _1270830 <= _1270865;
if (_1270866) goto l1270867; else goto l1271052;
l1271052: ;
union variant_220130 _1271053;
_1271053.qs32 = _1270865;
struct_BoundaryMode_220129 _1271054;
_1271054.e0 = 0;
_1271054.e1 = _1271053;
pbh_upper_1270870 = _1271054;
goto l1270868;
l1270867: ;
union variant_220130 _1265919_5499;
_1265919_5499.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5501;
_1265920_5501.e0 = 1;
_1265920_5501.e1 = _1265919_5499;
pbh_upper_1270870 = _1265920_5501;
goto l1270868;
l1270868: ;
bh_upper_1270870 = pbh_upper_1270870;
unsigned int _1270873;
_1270873 = bh_upper_1270870.e0;
union variant_220130 _1270877;
_1270877 = bh_upper_1270870.e1;
bool _1270874;
_1270874 = _1270873 == 0;
union variant_220130 _1270880;
_1270880 = bh_lower_1270864.e1;
unsigned int _1270871;
_1270871 = bh_lower_1270864.e0;
bool _1270872;
_1270872 = _1270871 == 0;
bool _1270875;
_1270875 = _1270872 & _1270874;
if (_1270875) goto l1270876; else goto l1271043;
l1271043: ;
bool _1271044;
_1271044 = _1270871 == 1;
if (_1271044) goto l1271045; else goto l1271047;
l1271047: ;
bool _1271048;
_1271048 = _1270873 == 1;
if (_1271048) goto l1271049; else goto l1271051;
l1271051: ;
// bottom: float r4_1265918_5513;
// bottom: p_1270889 = r4_1265918_5513;
goto l1270887;
l1271049: ;
float c_1271050;
c_1271050 = _1270877.pf32;
p_1270889 = c_1271050;
goto l1270887;
l1271045: ;
float c_1271046;
c_1271046 = _1270880.pf32;
p_1270889 = c_1271046;
goto l1270887;
l1270876: ;
int y_1270878;
y_1270878 = _1270877.qs32;
int _1270879;
_1270879 = y_1270878 * _1270849;
int x_1270881;
x_1270881 = _1270880.qs32;
int _1270882;
_1270882 = _1270879 + x_1270881;
float* idx_1270883;
idx_1270883 = _1000850_1270797 + _1270882;
_1270886 = __ldg(idx_1270883);
p_1270886 = _1270886;
l1270884: ;
_1270886 = p_1270886;
p_1270889 = _1270886;
goto l1270887;
l1270887: ;
_1270889 = p_1270889;
int _1270890;
_1270890 = -1 + gid_x_1270824;
bool _1270891;
_1270891 = _1270890 < 0;
if (_1270891) goto l1270892; else goto l1271040;
l1271040: ;
union variant_220130 _1271041;
_1271041.qs32 = _1270890;
struct_BoundaryMode_220129 _1271042;
_1271042.e0 = 0;
_1271042.e1 = _1271041;
pbh_lower_1270895 = _1271042;
goto l1270893;
l1270892: ;
union variant_220130 _1265919_5519;
_1265919_5519.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5521;
_1265920_5521.e0 = 1;
_1265920_5521.e1 = _1265919_5519;
pbh_lower_1270895 = _1265920_5521;
goto l1270893;
l1270893: ;
bh_lower_1270895 = pbh_lower_1270895;
if (_1270836) goto l1270896; else goto l1271039;
l1271039: ;
pbh_upper_1270899 = _1271026;
goto l1270897;
l1270896: ;
union variant_220130 _1265919_5525;
_1265919_5525.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5527;
_1265920_5527.e0 = 1;
_1265920_5527.e1 = _1265919_5525;
pbh_upper_1270899 = _1265920_5527;
goto l1270897;
l1270897: ;
bh_upper_1270899 = pbh_upper_1270899;
union variant_220130 _1270906;
_1270906 = bh_upper_1270899.e1;
unsigned int _1270900;
_1270900 = bh_lower_1270895.e0;
union variant_220130 _1270909;
_1270909 = bh_lower_1270895.e1;
unsigned int _1270902;
_1270902 = bh_upper_1270899.e0;
bool _1270903;
_1270903 = _1270902 == 0;
bool _1270901;
_1270901 = _1270900 == 0;
bool _1270904;
_1270904 = _1270901 & _1270903;
if (_1270904) goto l1270905; else goto l1271030;
l1271030: ;
bool _1271031;
_1271031 = _1270900 == 1;
if (_1271031) goto l1271032; else goto l1271034;
l1271034: ;
bool _1271035;
_1271035 = _1270902 == 1;
if (_1271035) goto l1271036; else goto l1271038;
l1271038: ;
// bottom: float r4_1265918_5539;
// bottom: p_1270918 = r4_1265918_5539;
goto l1270916;
l1271036: ;
float c_1271037;
c_1271037 = _1270906.pf32;
p_1270918 = c_1271037;
goto l1270916;
l1271032: ;
float c_1271033;
c_1271033 = _1270909.pf32;
p_1270918 = c_1271033;
goto l1270916;
l1270905: ;
int x_1270910;
x_1270910 = _1270909.qs32;
int y_1270907;
y_1270907 = _1270906.qs32;
int _1270908;
_1270908 = y_1270907 * _1270849;
int _1270911;
_1270911 = _1270908 + x_1270910;
float* idx_1270912;
idx_1270912 = _1000850_1270797 + _1270911;
_1270915 = __ldg(idx_1270912);
p_1270915 = _1270915;
l1270913: ;
_1270915 = p_1270915;
p_1270918 = _1270915;
goto l1270916;
l1270916: ;
_1270918 = p_1270918;
int _1270919;
_1270919 = 1 + gid_x_1270824;
bool _1270920;
_1270920 = _1270919 < 0;
if (_1270920) goto l1270921; else goto l1271027;
l1271027: ;
union variant_220130 _1271028;
_1271028.qs32 = _1270919;
struct_BoundaryMode_220129 _1271029;
_1271029.e0 = 0;
_1271029.e1 = _1271028;
pbh_lower_1270924 = _1271029;
goto l1270922;
l1270921: ;
union variant_220130 _1265919_5545;
_1265919_5545.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5547;
_1265920_5547.e0 = 1;
_1265920_5547.e1 = _1265919_5545;
pbh_lower_1270924 = _1265920_5547;
goto l1270922;
l1270922: ;
bh_lower_1270924 = pbh_lower_1270924;
if (_1270836) goto l1270925; else goto l1271024;
l1271024: ;
pbh_upper_1270928 = _1271026;
goto l1270926;
l1270925: ;
union variant_220130 _1265919_5551;
_1265919_5551.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5553;
_1265920_5553.e0 = 1;
_1265920_5553.e1 = _1265919_5551;
pbh_upper_1270928 = _1265920_5553;
goto l1270926;
l1270926: ;
bh_upper_1270928 = pbh_upper_1270928;
union variant_220130 _1270935;
_1270935 = bh_upper_1270928.e1;
unsigned int _1270929;
_1270929 = bh_lower_1270924.e0;
bool _1270930;
_1270930 = _1270929 == 0;
union variant_220130 _1270938;
_1270938 = bh_lower_1270924.e1;
unsigned int _1270931;
_1270931 = bh_upper_1270928.e0;
bool _1270932;
_1270932 = _1270931 == 0;
bool _1270933;
_1270933 = _1270930 & _1270932;
if (_1270933) goto l1270934; else goto l1271015;
l1271015: ;
bool _1271016;
_1271016 = _1270929 == 1;
if (_1271016) goto l1271017; else goto l1271019;
l1271019: ;
bool _1271020;
_1271020 = _1270931 == 1;
if (_1271020) goto l1271021; else goto l1271023;
l1271023: ;
// bottom: float r4_1265918_5565;
// bottom: p_1270947 = r4_1265918_5565;
goto l1270945;
l1271021: ;
float c_1271022;
c_1271022 = _1270935.pf32;
p_1270947 = c_1271022;
goto l1270945;
l1271017: ;
float c_1271018;
c_1271018 = _1270938.pf32;
p_1270947 = c_1271018;
goto l1270945;
l1270934: ;
int x_1270939;
x_1270939 = _1270938.qs32;
int y_1270936;
y_1270936 = _1270935.qs32;
int _1270937;
_1270937 = y_1270936 * _1270849;
int _1270940;
_1270940 = _1270937 + x_1270939;
float* idx_1270941;
idx_1270941 = _1000850_1270797 + _1270940;
_1270944 = __ldg(idx_1270941);
p_1270944 = _1270944;
l1270942: ;
_1270944 = p_1270944;
p_1270947 = _1270944;
goto l1270945;
l1270945: ;
_1270947 = p_1270947;
if (_1270825) goto l1270948; else goto l1271012;
l1271012: ;
pbh_lower_1270951 = _1271014;
goto l1270949;
l1270948: ;
union variant_220130 _1265919_5566;
_1265919_5566.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5568;
_1265920_5568.e0 = 1;
_1265920_5568.e1 = _1265919_5566;
pbh_lower_1270951 = _1265920_5568;
goto l1270949;
l1270949: ;
bh_lower_1270951 = pbh_lower_1270951;
int _1270952;
_1270952 = 1 + gid_y_1270835;
bool _1270953;
_1270953 = _1270830 <= _1270952;
if (_1270953) goto l1270954; else goto l1271009;
l1271009: ;
union variant_220130 _1271010;
_1271010.qs32 = _1270952;
struct_BoundaryMode_220129 _1271011;
_1271011.e0 = 0;
_1271011.e1 = _1271010;
pbh_upper_1270957 = _1271011;
goto l1270955;
l1270954: ;
union variant_220130 _1265919_5576;
_1265919_5576.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5578;
_1265920_5578.e0 = 1;
_1265920_5578.e1 = _1265919_5576;
pbh_upper_1270957 = _1265920_5578;
goto l1270955;
l1270955: ;
bh_upper_1270957 = pbh_upper_1270957;
union variant_220130 _1270967;
_1270967 = bh_lower_1270951.e1;
unsigned int _1270958;
_1270958 = bh_lower_1270951.e0;
unsigned int _1270960;
_1270960 = bh_upper_1270957.e0;
union variant_220130 _1270964;
_1270964 = bh_upper_1270957.e1;
bool _1270959;
_1270959 = _1270958 == 0;
bool _1270961;
_1270961 = _1270960 == 0;
bool _1270962;
_1270962 = _1270959 & _1270961;
if (_1270962) goto l1270963; else goto l1271000;
l1271000: ;
bool _1271001;
_1271001 = _1270958 == 1;
if (_1271001) goto l1271002; else goto l1271004;
l1271004: ;
bool _1271005;
_1271005 = _1270960 == 1;
if (_1271005) goto l1271006; else goto l1271008;
l1271008: ;
// bottom: float r4_1265918_5590;
// bottom: p_1270976 = r4_1265918_5590;
goto l1270974;
l1271006: ;
float c_1271007;
c_1271007 = _1270964.pf32;
p_1270976 = c_1271007;
goto l1270974;
l1271002: ;
float c_1271003;
c_1271003 = _1270967.pf32;
p_1270976 = c_1271003;
goto l1270974;
l1270963: ;
int x_1270968;
x_1270968 = _1270967.qs32;
int y_1270965;
y_1270965 = _1270964.qs32;
int _1270966;
_1270966 = y_1270965 * _1270849;
int _1270969;
_1270969 = _1270966 + x_1270968;
float* idx_1270970;
idx_1270970 = _1000850_1270797 + _1270969;
_1270973 = __ldg(idx_1270970);
p_1270973 = _1270973;
l1270971: ;
_1270973 = p_1270973;
p_1270976 = _1270973;
goto l1270974;
l1270974: ;
_1270976 = p_1270976;
float _1270992;
_1270992 = 2.500000e-01f * _1270918;
float _1270981;
_1270981 = 2.000000e-01f * _1270860;
float _1270996;
_1270996 = 2.500000e-01f * _1270976;
float _1270987;
_1270987 = _1270986;
int _1270977;
_1270977 = _1000854_1270801.e3;
float _1270994;
_1270994 = 2.500000e-01f * _1270947;
float _1270990;
_1270990 = 2.500000e-01f * _1270889;
float _1270988;
_1270988 = 2.000000e-01f * _1270987;
int _1270978;
_1270978 = gid_y_1270835 * _1270977;
float _1270991;
_1270991 = 0.000000e+00f + _1270990;
float _1270989;
_1270989 = _1270981 + _1270988;
int _1270979;
_1270979 = _1270978 + gid_x_1270824;
float _1270993;
_1270993 = _1270991 + _1270992;
float* idx_1270980;
idx_1270980 = _1000852_1270799 + _1270979;
float _1270995;
_1270995 = _1270993 + _1270994;
float _1270997;
_1270997 = _1270995 + _1270996;
float val_1270998;
val_1270998 = _1270989 + _1270997;
*idx_1270980 = val_1270998;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1012460(struct_Img_220118 _1012463_1278614, struct_Img_220118 _1012464_1278615, float* _1012465_1278616, struct_Img_220118 _1012466_1278617, float* _1012467_1278618, float* _1012468_1278619) {
int _1278622;
int p_1278622;
int _1278625;
int p_1278625;
int _1278628;
int p_1278628;
int _1278631;
int p_1278631;
int _1278634;
int p_1278634;
int _1278637;
int p_1278637;
int _1278640;
int p_1278640;
struct_BoundaryMode_220129 bh_upper_1278651;
struct_BoundaryMode_220129 pbh_upper_1278651;
struct_BoundaryMode_220129 bh_lower_1278658;
struct_BoundaryMode_220129 pbh_lower_1278658;
float _1278675;
float p_1278675;
float _1278678;
float p_1278678;
struct_BoundaryMode_220129 bh_upper_1278682;
struct_BoundaryMode_220129 pbh_upper_1278682;
struct_BoundaryMode_220129 bh_lower_1278688;
struct_BoundaryMode_220129 pbh_lower_1278688;
float _1278704;
float p_1278704;
float _1278707;
float p_1278707;
struct_BoundaryMode_220129 bh_upper_1278713;
struct_BoundaryMode_220129 pbh_upper_1278713;
struct_BoundaryMode_220129 bh_lower_1278717;
struct_BoundaryMode_220129 pbh_lower_1278717;
float _1278733;
float p_1278733;
float _1278736;
float p_1278736;
struct_BoundaryMode_220129 bh_upper_1278742;
struct_BoundaryMode_220129 pbh_upper_1278742;
struct_BoundaryMode_220129 bh_lower_1278746;
struct_BoundaryMode_220129 pbh_lower_1278746;
float _1278762;
float p_1278762;
float _1278765;
float p_1278765;
struct_BoundaryMode_220129 bh_upper_1278769;
struct_BoundaryMode_220129 pbh_upper_1278769;
struct_BoundaryMode_220129 bh_lower_1278775;
struct_BoundaryMode_220129 pbh_lower_1278775;
float _1278791;
float p_1278791;
float _1278794;
float p_1278794;
_1278622 = threadIdx_x();
p_1278622 = _1278622;
l1278620: ;
_1278622 = p_1278622;
_1278625 = blockDim_x();
p_1278625 = _1278625;
l1278623: ;
_1278625 = p_1278625;
_1278628 = blockIdx_x();
p_1278628 = _1278628;
l1278626: ;
_1278628 = p_1278628;
_1278631 = threadIdx_y();
p_1278631 = _1278631;
l1278629: ;
_1278631 = p_1278631;
_1278634 = blockDim_y();
p_1278634 = _1278634;
l1278632: ;
_1278634 = p_1278634;
_1278637 = blockIdx_y();
p_1278637 = _1278637;
l1278635: ;
_1278637 = p_1278637;
_1278640 = blockDim_y();
p_1278640 = _1278640;
l1278638: ;
_1278640 = p_1278640;
int _1278642;
_1278642 = _1012466_1278617.e1;
int _1278641;
_1278641 = _1012463_1278614.e1;
int _1278645;
_1278645 = _1278625 * _1278628;
int _1278643;
_1278643 = _1278642 - 128;
int _1278644;
_1278644 = _1278643 + _1278622;
int gid_x_1278646;
gid_x_1278646 = _1278644 + _1278645;
union variant_220130 _1278831;
_1278831.qs32 = gid_x_1278646;
bool _1278647;
_1278647 = _1278641 <= gid_x_1278646;
struct_BoundaryMode_220129 _1278832;
_1278832.e0 = 0;
_1278832.e1 = _1278831;
if (_1278647) goto l1278648; else goto l1278885;
l1278885: ;
pbh_upper_1278651 = _1278832;
goto l1278649;
l1278648: ;
union variant_220130 _1265919_5605;
_1265919_5605.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5607;
_1265920_5607.e0 = 1;
_1265920_5607.e1 = _1265919_5605;
pbh_upper_1278651 = _1265920_5607;
goto l1278649;
l1278649: ;
bh_upper_1278651 = pbh_upper_1278651;
int _1278652;
_1278652 = _1278634 * _1278637;
int gid_y_1278653;
gid_y_1278653 = _1278631 + _1278652;
union variant_220130 _1278843;
_1278843.qs32 = gid_y_1278653;
bool _1278654;
_1278654 = gid_y_1278653 < 0;
struct_BoundaryMode_220129 _1278844;
_1278844.e0 = 0;
_1278844.e1 = _1278843;
if (_1278654) goto l1278655; else goto l1278884;
l1278884: ;
pbh_lower_1278658 = _1278844;
goto l1278656;
l1278655: ;
union variant_220130 _1265919_5615;
_1265919_5615.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5617;
_1265920_5617.e0 = 1;
_1265920_5617.e1 = _1265919_5615;
pbh_lower_1278658 = _1265920_5617;
goto l1278656;
l1278656: ;
bh_lower_1278658 = pbh_lower_1278658;
union variant_220130 _1278669;
_1278669 = bh_upper_1278651.e1;
int _1278667;
_1278667 = _1012463_1278614.e3;
union variant_220130 _1278665;
_1278665 = bh_lower_1278658.e1;
unsigned int _1278661;
_1278661 = bh_lower_1278658.e0;
bool _1278662;
_1278662 = _1278661 == 0;
unsigned int _1278659;
_1278659 = bh_upper_1278651.e0;
bool _1278660;
_1278660 = _1278659 == 0;
bool _1278663;
_1278663 = _1278660 & _1278662;
if (_1278663) goto l1278664; else goto l1278875;
l1278875: ;
bool _1278876;
_1278876 = _1278659 == 1;
if (_1278876) goto l1278877; else goto l1278879;
l1278879: ;
bool _1278880;
_1278880 = _1278661 == 1;
if (_1278880) goto l1278881; else goto l1278883;
l1278883: ;
// bottom: float r4_1265918_5630;
// bottom: p_1278678 = r4_1265918_5630;
goto l1278676;
l1278881: ;
float c_1278882;
c_1278882 = _1278665.pf32;
p_1278678 = c_1278882;
goto l1278676;
l1278877: ;
float c_1278878;
c_1278878 = _1278669.pf32;
p_1278678 = c_1278878;
goto l1278676;
l1278664: ;
int x_1278670;
x_1278670 = _1278669.qs32;
int y_1278666;
y_1278666 = _1278665.qs32;
int _1278668;
_1278668 = y_1278666 * _1278667;
int _1278671;
_1278671 = _1278668 + x_1278670;
float* idx_1278672;
idx_1278672 = _1012467_1278618 + _1278671;
_1278675 = __ldg(idx_1278672);
p_1278675 = _1278675;
l1278673: ;
_1278675 = p_1278675;
p_1278678 = _1278675;
goto l1278676;
l1278676: ;
_1278678 = p_1278678;
int _1278800;
_1278800 = _1012464_1278615.e3;
int _1278801;
_1278801 = gid_y_1278653 * _1278800;
int _1278802;
_1278802 = _1278801 + gid_x_1278646;
float* idx_1278803;
idx_1278803 = _1012468_1278619 + _1278802;
float _1278804;
_1278804 = *idx_1278803;
if (_1278647) goto l1278679; else goto l1278874;
l1278874: ;
pbh_upper_1278682 = _1278832;
goto l1278680;
l1278679: ;
union variant_220130 _1265919_5632;
_1265919_5632.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5634;
_1265920_5634.e0 = 1;
_1265920_5634.e1 = _1265919_5632;
pbh_upper_1278682 = _1265920_5634;
goto l1278680;
l1278680: ;
bh_upper_1278682 = pbh_upper_1278682;
int _1278683;
_1278683 = -1 + gid_y_1278653;
bool _1278684;
_1278684 = _1278683 < 0;
if (_1278684) goto l1278685; else goto l1278870;
l1278870: ;
union variant_220130 _1278871;
_1278871.qs32 = _1278683;
struct_BoundaryMode_220129 _1278872;
_1278872.e0 = 0;
_1278872.e1 = _1278871;
pbh_lower_1278688 = _1278872;
goto l1278686;
l1278685: ;
union variant_220130 _1265919_5643;
_1265919_5643.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5645;
_1265920_5645.e0 = 1;
_1265920_5645.e1 = _1265919_5643;
pbh_lower_1278688 = _1265920_5645;
goto l1278686;
l1278686: ;
bh_lower_1278688 = pbh_lower_1278688;
union variant_220130 _1278695;
_1278695 = bh_lower_1278688.e1;
unsigned int _1278691;
_1278691 = bh_lower_1278688.e0;
union variant_220130 _1278698;
_1278698 = bh_upper_1278682.e1;
unsigned int _1278689;
_1278689 = bh_upper_1278682.e0;
bool _1278692;
_1278692 = _1278691 == 0;
bool _1278690;
_1278690 = _1278689 == 0;
bool _1278693;
_1278693 = _1278690 & _1278692;
if (_1278693) goto l1278694; else goto l1278861;
l1278861: ;
bool _1278862;
_1278862 = _1278689 == 1;
if (_1278862) goto l1278863; else goto l1278865;
l1278865: ;
bool _1278866;
_1278866 = _1278691 == 1;
if (_1278866) goto l1278867; else goto l1278869;
l1278869: ;
// bottom: float r4_1265918_5657;
// bottom: p_1278707 = r4_1265918_5657;
goto l1278705;
l1278867: ;
float c_1278868;
c_1278868 = _1278695.pf32;
p_1278707 = c_1278868;
goto l1278705;
l1278863: ;
float c_1278864;
c_1278864 = _1278698.pf32;
p_1278707 = c_1278864;
goto l1278705;
l1278694: ;
int x_1278699;
x_1278699 = _1278698.qs32;
int y_1278696;
y_1278696 = _1278695.qs32;
int _1278697;
_1278697 = y_1278696 * _1278667;
int _1278700;
_1278700 = _1278697 + x_1278699;
float* idx_1278701;
idx_1278701 = _1012467_1278618 + _1278700;
_1278704 = __ldg(idx_1278701);
p_1278704 = _1278704;
l1278702: ;
_1278704 = p_1278704;
p_1278707 = _1278704;
goto l1278705;
l1278705: ;
_1278707 = p_1278707;
int _1278708;
_1278708 = -1 + gid_x_1278646;
bool _1278709;
_1278709 = _1278641 <= _1278708;
if (_1278709) goto l1278710; else goto l1278858;
l1278858: ;
union variant_220130 _1278859;
_1278859.qs32 = _1278708;
struct_BoundaryMode_220129 _1278860;
_1278860.e0 = 0;
_1278860.e1 = _1278859;
pbh_upper_1278713 = _1278860;
goto l1278711;
l1278710: ;
union variant_220130 _1265919_5662;
_1265919_5662.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5664;
_1265920_5664.e0 = 1;
_1265920_5664.e1 = _1265919_5662;
pbh_upper_1278713 = _1265920_5664;
goto l1278711;
l1278711: ;
bh_upper_1278713 = pbh_upper_1278713;
if (_1278654) goto l1278714; else goto l1278857;
l1278857: ;
pbh_lower_1278717 = _1278844;
goto l1278715;
l1278714: ;
union variant_220130 _1265919_5668;
_1265919_5668.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5670;
_1265920_5670.e0 = 1;
_1265920_5670.e1 = _1265919_5668;
pbh_lower_1278717 = _1265920_5670;
goto l1278715;
l1278715: ;
bh_lower_1278717 = pbh_lower_1278717;
union variant_220130 _1278724;
_1278724 = bh_lower_1278717.e1;
unsigned int _1278720;
_1278720 = bh_lower_1278717.e0;
bool _1278721;
_1278721 = _1278720 == 0;
union variant_220130 _1278727;
_1278727 = bh_upper_1278713.e1;
unsigned int _1278718;
_1278718 = bh_upper_1278713.e0;
bool _1278719;
_1278719 = _1278718 == 0;
bool _1278722;
_1278722 = _1278719 & _1278721;
if (_1278722) goto l1278723; else goto l1278848;
l1278848: ;
bool _1278849;
_1278849 = _1278718 == 1;
if (_1278849) goto l1278850; else goto l1278852;
l1278852: ;
bool _1278853;
_1278853 = _1278720 == 1;
if (_1278853) goto l1278854; else goto l1278856;
l1278856: ;
// bottom: float r4_1265918_5682;
// bottom: p_1278736 = r4_1265918_5682;
goto l1278734;
l1278854: ;
float c_1278855;
c_1278855 = _1278724.pf32;
p_1278736 = c_1278855;
goto l1278734;
l1278850: ;
float c_1278851;
c_1278851 = _1278727.pf32;
p_1278736 = c_1278851;
goto l1278734;
l1278723: ;
int y_1278725;
y_1278725 = _1278724.qs32;
int _1278726;
_1278726 = y_1278725 * _1278667;
int x_1278728;
x_1278728 = _1278727.qs32;
int _1278729;
_1278729 = _1278726 + x_1278728;
float* idx_1278730;
idx_1278730 = _1012467_1278618 + _1278729;
_1278733 = __ldg(idx_1278730);
p_1278733 = _1278733;
l1278731: ;
_1278733 = p_1278733;
p_1278736 = _1278733;
goto l1278734;
l1278734: ;
_1278736 = p_1278736;
int _1278737;
_1278737 = 1 + gid_x_1278646;
bool _1278738;
_1278738 = _1278641 <= _1278737;
if (_1278738) goto l1278739; else goto l1278845;
l1278845: ;
union variant_220130 _1278846;
_1278846.qs32 = _1278737;
struct_BoundaryMode_220129 _1278847;
_1278847.e0 = 0;
_1278847.e1 = _1278846;
pbh_upper_1278742 = _1278847;
goto l1278740;
l1278739: ;
union variant_220130 _1265919_5687;
_1265919_5687.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5689;
_1265920_5689.e0 = 1;
_1265920_5689.e1 = _1265919_5687;
pbh_upper_1278742 = _1265920_5689;
goto l1278740;
l1278740: ;
bh_upper_1278742 = pbh_upper_1278742;
if (_1278654) goto l1278743; else goto l1278842;
l1278842: ;
pbh_lower_1278746 = _1278844;
goto l1278744;
l1278743: ;
union variant_220130 _1265919_5693;
_1265919_5693.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5695;
_1265920_5695.e0 = 1;
_1265920_5695.e1 = _1265919_5693;
pbh_lower_1278746 = _1265920_5695;
goto l1278744;
l1278744: ;
bh_lower_1278746 = pbh_lower_1278746;
union variant_220130 _1278756;
_1278756 = bh_upper_1278742.e1;
unsigned int _1278749;
_1278749 = bh_lower_1278746.e0;
union variant_220130 _1278753;
_1278753 = bh_lower_1278746.e1;
unsigned int _1278747;
_1278747 = bh_upper_1278742.e0;
bool _1278750;
_1278750 = _1278749 == 0;
bool _1278748;
_1278748 = _1278747 == 0;
bool _1278751;
_1278751 = _1278748 & _1278750;
if (_1278751) goto l1278752; else goto l1278833;
l1278833: ;
bool _1278834;
_1278834 = _1278747 == 1;
if (_1278834) goto l1278835; else goto l1278837;
l1278837: ;
bool _1278838;
_1278838 = _1278749 == 1;
if (_1278838) goto l1278839; else goto l1278841;
l1278841: ;
// bottom: float r4_1265918_5707;
// bottom: p_1278765 = r4_1265918_5707;
goto l1278763;
l1278839: ;
float c_1278840;
c_1278840 = _1278753.pf32;
p_1278765 = c_1278840;
goto l1278763;
l1278835: ;
float c_1278836;
c_1278836 = _1278756.pf32;
p_1278765 = c_1278836;
goto l1278763;
l1278752: ;
int x_1278757;
x_1278757 = _1278756.qs32;
int y_1278754;
y_1278754 = _1278753.qs32;
int _1278755;
_1278755 = y_1278754 * _1278667;
int _1278758;
_1278758 = _1278755 + x_1278757;
float* idx_1278759;
idx_1278759 = _1012467_1278618 + _1278758;
_1278762 = __ldg(idx_1278759);
p_1278762 = _1278762;
l1278760: ;
_1278762 = p_1278762;
p_1278765 = _1278762;
goto l1278763;
l1278763: ;
_1278765 = p_1278765;
if (_1278647) goto l1278766; else goto l1278830;
l1278830: ;
pbh_upper_1278769 = _1278832;
goto l1278767;
l1278766: ;
union variant_220130 _1265919_5708;
_1265919_5708.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5710;
_1265920_5710.e0 = 1;
_1265920_5710.e1 = _1265919_5708;
pbh_upper_1278769 = _1265920_5710;
goto l1278767;
l1278767: ;
bh_upper_1278769 = pbh_upper_1278769;
int _1278770;
_1278770 = 1 + gid_y_1278653;
bool _1278771;
_1278771 = _1278770 < 0;
if (_1278771) goto l1278772; else goto l1278827;
l1278827: ;
union variant_220130 _1278828;
_1278828.qs32 = _1278770;
struct_BoundaryMode_220129 _1278829;
_1278829.e0 = 0;
_1278829.e1 = _1278828;
pbh_lower_1278775 = _1278829;
goto l1278773;
l1278772: ;
union variant_220130 _1265919_5719;
_1265919_5719.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5721;
_1265920_5721.e0 = 1;
_1265920_5721.e1 = _1265919_5719;
pbh_lower_1278775 = _1265920_5721;
goto l1278773;
l1278773: ;
bh_lower_1278775 = pbh_lower_1278775;
union variant_220130 _1278785;
_1278785 = bh_upper_1278769.e1;
unsigned int _1278778;
_1278778 = bh_lower_1278775.e0;
union variant_220130 _1278782;
_1278782 = bh_lower_1278775.e1;
bool _1278779;
_1278779 = _1278778 == 0;
unsigned int _1278776;
_1278776 = bh_upper_1278769.e0;
bool _1278777;
_1278777 = _1278776 == 0;
bool _1278780;
_1278780 = _1278777 & _1278779;
if (_1278780) goto l1278781; else goto l1278818;
l1278818: ;
bool _1278819;
_1278819 = _1278776 == 1;
if (_1278819) goto l1278820; else goto l1278822;
l1278822: ;
bool _1278823;
_1278823 = _1278778 == 1;
if (_1278823) goto l1278824; else goto l1278826;
l1278826: ;
// bottom: float r4_1265918_5733;
// bottom: p_1278794 = r4_1265918_5733;
goto l1278792;
l1278824: ;
float c_1278825;
c_1278825 = _1278782.pf32;
p_1278794 = c_1278825;
goto l1278792;
l1278820: ;
float c_1278821;
c_1278821 = _1278785.pf32;
p_1278794 = c_1278821;
goto l1278792;
l1278781: ;
int x_1278786;
x_1278786 = _1278785.qs32;
int y_1278783;
y_1278783 = _1278782.qs32;
int _1278784;
_1278784 = y_1278783 * _1278667;
int _1278787;
_1278787 = _1278784 + x_1278786;
float* idx_1278788;
idx_1278788 = _1012467_1278618 + _1278787;
_1278791 = __ldg(idx_1278788);
p_1278791 = _1278791;
l1278789: ;
_1278791 = p_1278791;
p_1278794 = _1278791;
goto l1278792;
l1278792: ;
_1278794 = p_1278794;
float _1278808;
_1278808 = 2.500000e-01f * _1278707;
float _1278814;
_1278814 = 2.500000e-01f * _1278794;
float _1278810;
_1278810 = 2.500000e-01f * _1278736;
float _1278809;
_1278809 = 0.000000e+00f + _1278808;
float _1278812;
_1278812 = 2.500000e-01f * _1278765;
int _1278795;
_1278795 = _1012466_1278617.e3;
float _1278799;
_1278799 = 2.000000e-01f * _1278678;
float _1278805;
_1278805 = _1278804;
float _1278811;
_1278811 = _1278809 + _1278810;
float _1278813;
_1278813 = _1278811 + _1278812;
int _1278796;
_1278796 = gid_y_1278653 * _1278795;
float _1278806;
_1278806 = 2.000000e-01f * _1278805;
float _1278815;
_1278815 = _1278813 + _1278814;
int _1278797;
_1278797 = _1278796 + gid_x_1278646;
float _1278807;
_1278807 = _1278799 + _1278806;
float val_1278816;
val_1278816 = _1278807 + _1278815;
float* idx_1278798;
idx_1278798 = _1012465_1278616 + _1278797;
*idx_1278798 = val_1278816;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1004827(struct_Img_220118 _1004830_1270331, struct_Img_220118 _1004831_1270332, float* _1004832_1270333, struct_Img_220118 _1004833_1270334, float* _1004834_1270335, float* _1004835_1270336) {
int _1270339;
int p_1270339;
int _1270342;
int p_1270342;
int _1270345;
int p_1270345;
int _1270348;
int p_1270348;
int _1270351;
int p_1270351;
int _1270354;
int p_1270354;
int _1270357;
int p_1270357;
struct_BoundaryMode_220129 bh_lower_1270364;
struct_BoundaryMode_220129 pbh_lower_1270364;
float _1270379;
float p_1270379;
float _1270382;
float p_1270382;
struct_BoundaryMode_220129 bh_lower_1270386;
struct_BoundaryMode_220129 pbh_lower_1270386;
float _1270397;
float p_1270397;
float _1270400;
float p_1270400;
struct_BoundaryMode_220129 bh_lower_1270406;
struct_BoundaryMode_220129 pbh_lower_1270406;
float _1270416;
float p_1270416;
float _1270419;
float p_1270419;
struct_BoundaryMode_220129 bh_lower_1270425;
struct_BoundaryMode_220129 pbh_lower_1270425;
float _1270435;
float p_1270435;
float _1270438;
float p_1270438;
struct_BoundaryMode_220129 bh_lower_1270442;
struct_BoundaryMode_220129 pbh_lower_1270442;
float _1270454;
float p_1270454;
float _1270457;
float p_1270457;
_1270339 = threadIdx_x();
p_1270339 = _1270339;
l1270337: ;
_1270339 = p_1270339;
_1270342 = blockDim_x();
p_1270342 = _1270342;
l1270340: ;
_1270342 = p_1270342;
_1270345 = blockIdx_x();
p_1270345 = _1270345;
l1270343: ;
_1270345 = p_1270345;
_1270348 = threadIdx_y();
p_1270348 = _1270348;
l1270346: ;
_1270348 = p_1270348;
_1270351 = blockDim_y();
p_1270351 = _1270351;
l1270349: ;
_1270351 = p_1270351;
_1270354 = blockIdx_y();
p_1270354 = _1270354;
l1270352: ;
_1270354 = p_1270354;
_1270357 = blockDim_y();
p_1270357 = _1270357;
l1270355: ;
_1270357 = p_1270357;
int _1270358;
_1270358 = _1270342 * _1270345;
int gid_x_1270359;
gid_x_1270359 = _1270339 + _1270358;
bool _1270360;
_1270360 = gid_x_1270359 < 0;
union variant_220130 _1270487;
_1270487.qs32 = gid_x_1270359;
struct_BoundaryMode_220129 _1270488;
_1270488.e0 = 0;
_1270488.e1 = _1270487;
if (_1270360) goto l1270361; else goto l1270517;
l1270517: ;
pbh_lower_1270364 = _1270488;
goto l1270362;
l1270361: ;
union variant_220130 _1265919_5746;
_1265919_5746.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5748;
_1265920_5748.e0 = 1;
_1265920_5748.e1 = _1265919_5746;
pbh_lower_1270364 = _1265920_5748;
goto l1270362;
l1270362: ;
bh_lower_1270364 = pbh_lower_1270364;
union variant_220130 _1270373;
_1270373 = bh_lower_1270364.e1;
int _1270371;
_1270371 = _1004831_1270332.e3;
unsigned int _1270365;
_1270365 = bh_lower_1270364.e0;
int _1270368;
_1270368 = _1270351 * _1270354;
bool _1270366;
_1270366 = _1270365 == 0;
int gid_y_1270369;
gid_y_1270369 = _1270348 + _1270368;
int _1270370;
_1270370 = 1 + gid_y_1270369;
int _1270372;
_1270372 = _1270370 * _1270371;
if (_1270366) goto l1270367; else goto l1270512;
l1270512: ;
bool _1270513;
_1270513 = _1270365 == 1;
if (_1270513) goto l1270514; else goto l1270516;
l1270516: ;
// bottom: float r4_1265918_5758;
// bottom: p_1270382 = r4_1265918_5758;
goto l1270380;
l1270514: ;
float c_1270515;
c_1270515 = _1270373.pf32;
p_1270382 = c_1270515;
goto l1270380;
l1270367: ;
int x_1270374;
x_1270374 = _1270373.qs32;
int _1270375;
_1270375 = _1270372 + x_1270374;
float* idx_1270376;
idx_1270376 = _1004832_1270333 + _1270375;
_1270379 = __ldg(idx_1270376);
p_1270379 = _1270379;
l1270377: ;
_1270379 = p_1270379;
p_1270382 = _1270379;
goto l1270380;
l1270380: ;
_1270382 = p_1270382;
int _1270463;
_1270463 = _1004833_1270334.e3;
int _1270464;
_1270464 = _1270370 * _1270463;
int _1270465;
_1270465 = _1270464 + gid_x_1270359;
float* idx_1270466;
idx_1270466 = _1004835_1270336 + _1270465;
float _1270467;
_1270467 = *idx_1270466;
if (_1270360) goto l1270383; else goto l1270511;
l1270511: ;
pbh_lower_1270386 = _1270488;
goto l1270384;
l1270383: ;
union variant_220130 _1265919_5760;
_1265919_5760.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5762;
_1265920_5762.e0 = 1;
_1265920_5762.e1 = _1265919_5760;
pbh_lower_1270386 = _1265920_5762;
goto l1270384;
l1270384: ;
bh_lower_1270386 = pbh_lower_1270386;
union variant_220130 _1270391;
_1270391 = bh_lower_1270386.e1;
unsigned int _1270387;
_1270387 = bh_lower_1270386.e0;
bool _1270388;
_1270388 = _1270387 == 0;
if (_1270388) goto l1270389; else goto l1270505;
l1270505: ;
bool _1270506;
_1270506 = _1270387 == 1;
if (_1270506) goto l1270507; else goto l1270509;
l1270509: ;
// bottom: float r4_1265918_5770;
// bottom: p_1270400 = r4_1265918_5770;
goto l1270398;
l1270507: ;
float c_1270508;
c_1270508 = _1270391.pf32;
p_1270400 = c_1270508;
goto l1270398;
l1270389: ;
int x_1270392;
x_1270392 = _1270391.qs32;
int _1270390;
_1270390 = gid_y_1270369 * _1270371;
int _1270393;
_1270393 = _1270390 + x_1270392;
float* idx_1270394;
idx_1270394 = _1004832_1270333 + _1270393;
_1270397 = __ldg(idx_1270394);
p_1270397 = _1270397;
l1270395: ;
_1270397 = p_1270397;
p_1270400 = _1270397;
goto l1270398;
l1270398: ;
_1270400 = p_1270400;
int _1270401;
_1270401 = -1 + gid_x_1270359;
bool _1270402;
_1270402 = _1270401 < 0;
if (_1270402) goto l1270403; else goto l1270502;
l1270502: ;
union variant_220130 _1270503;
_1270503.qs32 = _1270401;
struct_BoundaryMode_220129 _1270504;
_1270504.e0 = 0;
_1270504.e1 = _1270503;
pbh_lower_1270406 = _1270504;
goto l1270404;
l1270403: ;
union variant_220130 _1265919_5776;
_1265919_5776.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5778;
_1265920_5778.e0 = 1;
_1265920_5778.e1 = _1265919_5776;
pbh_lower_1270406 = _1265920_5778;
goto l1270404;
l1270404: ;
bh_lower_1270406 = pbh_lower_1270406;
union variant_220130 _1270410;
_1270410 = bh_lower_1270406.e1;
unsigned int _1270407;
_1270407 = bh_lower_1270406.e0;
bool _1270408;
_1270408 = _1270407 == 0;
if (_1270408) goto l1270409; else goto l1270497;
l1270497: ;
bool _1270498;
_1270498 = _1270407 == 1;
if (_1270498) goto l1270499; else goto l1270501;
l1270501: ;
// bottom: float r4_1265918_5786;
// bottom: p_1270419 = r4_1265918_5786;
goto l1270417;
l1270499: ;
float c_1270500;
c_1270500 = _1270410.pf32;
p_1270419 = c_1270500;
goto l1270417;
l1270409: ;
int x_1270411;
x_1270411 = _1270410.qs32;
int _1270412;
_1270412 = _1270372 + x_1270411;
float* idx_1270413;
idx_1270413 = _1004832_1270333 + _1270412;
_1270416 = __ldg(idx_1270413);
p_1270416 = _1270416;
l1270414: ;
_1270416 = p_1270416;
p_1270419 = _1270416;
goto l1270417;
l1270417: ;
_1270419 = p_1270419;
int _1270420;
_1270420 = 1 + gid_x_1270359;
bool _1270421;
_1270421 = _1270420 < 0;
if (_1270421) goto l1270422; else goto l1270494;
l1270494: ;
union variant_220130 _1270495;
_1270495.qs32 = _1270420;
struct_BoundaryMode_220129 _1270496;
_1270496.e0 = 0;
_1270496.e1 = _1270495;
pbh_lower_1270425 = _1270496;
goto l1270423;
l1270422: ;
union variant_220130 _1265919_5792;
_1265919_5792.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5794;
_1265920_5794.e0 = 1;
_1265920_5794.e1 = _1265919_5792;
pbh_lower_1270425 = _1265920_5794;
goto l1270423;
l1270423: ;
bh_lower_1270425 = pbh_lower_1270425;
union variant_220130 _1270429;
_1270429 = bh_lower_1270425.e1;
unsigned int _1270426;
_1270426 = bh_lower_1270425.e0;
bool _1270427;
_1270427 = _1270426 == 0;
if (_1270427) goto l1270428; else goto l1270489;
l1270489: ;
bool _1270490;
_1270490 = _1270426 == 1;
if (_1270490) goto l1270491; else goto l1270493;
l1270493: ;
// bottom: float r4_1265918_5802;
// bottom: p_1270438 = r4_1265918_5802;
goto l1270436;
l1270491: ;
float c_1270492;
c_1270492 = _1270429.pf32;
p_1270438 = c_1270492;
goto l1270436;
l1270428: ;
int x_1270430;
x_1270430 = _1270429.qs32;
int _1270431;
_1270431 = _1270372 + x_1270430;
float* idx_1270432;
idx_1270432 = _1004832_1270333 + _1270431;
_1270435 = __ldg(idx_1270432);
p_1270435 = _1270435;
l1270433: ;
_1270435 = p_1270435;
p_1270438 = _1270435;
goto l1270436;
l1270436: ;
_1270438 = p_1270438;
if (_1270360) goto l1270439; else goto l1270486;
l1270486: ;
pbh_lower_1270442 = _1270488;
goto l1270440;
l1270439: ;
union variant_220130 _1265919_5803;
_1265919_5803.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5805;
_1265920_5805.e0 = 1;
_1265920_5805.e1 = _1265919_5803;
pbh_lower_1270442 = _1265920_5805;
goto l1270440;
l1270440: ;
bh_lower_1270442 = pbh_lower_1270442;
unsigned int _1270443;
_1270443 = bh_lower_1270442.e0;
union variant_220130 _1270448;
_1270448 = bh_lower_1270442.e1;
bool _1270444;
_1270444 = _1270443 == 0;
if (_1270444) goto l1270445; else goto l1270481;
l1270481: ;
bool _1270482;
_1270482 = _1270443 == 1;
if (_1270482) goto l1270483; else goto l1270485;
l1270485: ;
// bottom: float r4_1265918_5813;
// bottom: p_1270457 = r4_1265918_5813;
goto l1270455;
l1270483: ;
float c_1270484;
c_1270484 = _1270448.pf32;
p_1270457 = c_1270484;
goto l1270455;
l1270445: ;
int _1270446;
_1270446 = 2 + gid_y_1270369;
int x_1270449;
x_1270449 = _1270448.qs32;
int _1270447;
_1270447 = _1270446 * _1270371;
int _1270450;
_1270450 = _1270447 + x_1270449;
float* idx_1270451;
idx_1270451 = _1004832_1270333 + _1270450;
_1270454 = __ldg(idx_1270451);
p_1270454 = _1270454;
l1270452: ;
_1270454 = p_1270454;
p_1270457 = _1270454;
goto l1270455;
l1270455: ;
_1270457 = p_1270457;
float _1270471;
_1270471 = 2.500000e-01f * _1270400;
float _1270462;
_1270462 = 2.000000e-01f * _1270382;
float _1270468;
_1270468 = _1270467;
int _1270458;
_1270458 = _1004830_1270331.e3;
float _1270473;
_1270473 = 2.500000e-01f * _1270419;
float _1270475;
_1270475 = 2.500000e-01f * _1270438;
float _1270477;
_1270477 = 2.500000e-01f * _1270457;
float _1270472;
_1270472 = 0.000000e+00f + _1270471;
float _1270474;
_1270474 = _1270472 + _1270473;
float _1270469;
_1270469 = 2.000000e-01f * _1270468;
int _1270459;
_1270459 = _1270370 * _1270458;
float _1270476;
_1270476 = _1270474 + _1270475;
float _1270478;
_1270478 = _1270476 + _1270477;
float _1270470;
_1270470 = _1270462 + _1270469;
int _1270460;
_1270460 = _1270459 + gid_x_1270359;
float val_1270479;
val_1270479 = _1270470 + _1270478;
float* idx_1270461;
idx_1270461 = _1004834_1270335 + _1270460;
*idx_1270461 = val_1270479;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1029611(struct_Img_220118 _1029614_1280872, float* _1029615_1280873, float* _1029616_1280874, struct_Img_220118 _1029617_1280875, struct_Img_220118 _1029618_1280876, float* _1029619_1280877) {
int _1280880;
int p_1280880;
int _1280883;
int p_1280883;
int _1280886;
int p_1280886;
int _1280889;
int p_1280889;
int _1280892;
int p_1280892;
int _1280895;
int p_1280895;
int _1280898;
int p_1280898;
struct_BoundaryMode_220129 bh_lower_1280905;
struct_BoundaryMode_220129 pbh_lower_1280905;
struct_BoundaryMode_220129 bh_upper_1280916;
struct_BoundaryMode_220129 pbh_upper_1280916;
float _1280933;
float p_1280933;
float _1280936;
float p_1280936;
struct_BoundaryMode_220129 bh_lower_1280940;
struct_BoundaryMode_220129 pbh_lower_1280940;
struct_BoundaryMode_220129 bh_upper_1280946;
struct_BoundaryMode_220129 pbh_upper_1280946;
float _1280962;
float p_1280962;
float _1280965;
float p_1280965;
struct_BoundaryMode_220129 bh_lower_1280971;
struct_BoundaryMode_220129 pbh_lower_1280971;
struct_BoundaryMode_220129 bh_upper_1280975;
struct_BoundaryMode_220129 pbh_upper_1280975;
float _1280991;
float p_1280991;
float _1280994;
float p_1280994;
struct_BoundaryMode_220129 bh_lower_1281000;
struct_BoundaryMode_220129 pbh_lower_1281000;
struct_BoundaryMode_220129 bh_upper_1281004;
struct_BoundaryMode_220129 pbh_upper_1281004;
float _1281020;
float p_1281020;
float _1281023;
float p_1281023;
struct_BoundaryMode_220129 bh_lower_1281027;
struct_BoundaryMode_220129 pbh_lower_1281027;
struct_BoundaryMode_220129 bh_upper_1281033;
struct_BoundaryMode_220129 pbh_upper_1281033;
float _1281049;
float p_1281049;
float _1281052;
float p_1281052;
_1280880 = threadIdx_x();
p_1280880 = _1280880;
l1280878: ;
_1280880 = p_1280880;
_1280883 = blockDim_x();
p_1280883 = _1280883;
l1280881: ;
_1280883 = p_1280883;
_1280886 = blockIdx_x();
p_1280886 = _1280886;
l1280884: ;
_1280886 = p_1280886;
_1280889 = threadIdx_y();
p_1280889 = _1280889;
l1280887: ;
_1280889 = p_1280889;
_1280892 = blockDim_y();
p_1280892 = _1280892;
l1280890: ;
_1280892 = p_1280892;
_1280895 = blockIdx_y();
p_1280895 = _1280895;
l1280893: ;
_1280895 = p_1280895;
_1280898 = blockDim_y();
p_1280898 = _1280898;
l1280896: ;
_1280898 = p_1280898;
int _1280899;
_1280899 = _1280883 * _1280886;
int gid_x_1280900;
gid_x_1280900 = _1280880 + _1280899;
union variant_220130 _1281089;
_1281089.qs32 = gid_x_1280900;
bool _1280901;
_1280901 = gid_x_1280900 < 0;
struct_BoundaryMode_220129 _1281090;
_1281090.e0 = 0;
_1281090.e1 = _1281089;
if (_1280901) goto l1280902; else goto l1281143;
l1281143: ;
pbh_lower_1280905 = _1281090;
goto l1280903;
l1280902: ;
union variant_220130 _1265919_5827;
_1265919_5827.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5829;
_1265920_5829.e0 = 1;
_1265920_5829.e1 = _1265919_5827;
pbh_lower_1280905 = _1265920_5829;
goto l1280903;
l1280903: ;
bh_lower_1280905 = pbh_lower_1280905;
int _1280906;
_1280906 = _1029617_1280875.e2;
int _1280907;
_1280907 = _1029618_1280876.e2;
int _1280910;
_1280910 = _1280892 * _1280895;
int _1280908;
_1280908 = _1280907 - 1;
int _1280909;
_1280909 = _1280908 + _1280889;
int gid_y_1280911;
gid_y_1280911 = _1280909 + _1280910;
union variant_220130 _1281101;
_1281101.qs32 = gid_y_1280911;
bool _1280912;
_1280912 = _1280906 <= gid_y_1280911;
struct_BoundaryMode_220129 _1281102;
_1281102.e0 = 0;
_1281102.e1 = _1281101;
if (_1280912) goto l1280913; else goto l1281142;
l1281142: ;
pbh_upper_1280916 = _1281102;
goto l1280914;
l1280913: ;
union variant_220130 _1265919_5839;
_1265919_5839.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5841;
_1265920_5841.e0 = 1;
_1265920_5841.e1 = _1265919_5839;
pbh_upper_1280916 = _1265920_5841;
goto l1280914;
l1280914: ;
bh_upper_1280916 = pbh_upper_1280916;
unsigned int _1280919;
_1280919 = bh_upper_1280916.e0;
unsigned int _1280917;
_1280917 = bh_lower_1280905.e0;
union variant_220130 _1280923;
_1280923 = bh_upper_1280916.e1;
int _1280925;
_1280925 = _1029617_1280875.e3;
union variant_220130 _1280927;
_1280927 = bh_lower_1280905.e1;
bool _1280920;
_1280920 = _1280919 == 0;
bool _1280918;
_1280918 = _1280917 == 0;
bool _1280921;
_1280921 = _1280918 & _1280920;
if (_1280921) goto l1280922; else goto l1281133;
l1281133: ;
bool _1281134;
_1281134 = _1280917 == 1;
if (_1281134) goto l1281135; else goto l1281137;
l1281137: ;
bool _1281138;
_1281138 = _1280919 == 1;
if (_1281138) goto l1281139; else goto l1281141;
l1281141: ;
// bottom: float r4_1265918_5854;
// bottom: p_1280936 = r4_1265918_5854;
goto l1280934;
l1281139: ;
float c_1281140;
c_1281140 = _1280923.pf32;
p_1280936 = c_1281140;
goto l1280934;
l1281135: ;
float c_1281136;
c_1281136 = _1280927.pf32;
p_1280936 = c_1281136;
goto l1280934;
l1280922: ;
int y_1280924;
y_1280924 = _1280923.qs32;
int x_1280928;
x_1280928 = _1280927.qs32;
int _1280926;
_1280926 = y_1280924 * _1280925;
int _1280929;
_1280929 = _1280926 + x_1280928;
float* idx_1280930;
idx_1280930 = _1029616_1280874 + _1280929;
_1280933 = __ldg(idx_1280930);
p_1280933 = _1280933;
l1280931: ;
_1280933 = p_1280933;
p_1280936 = _1280933;
goto l1280934;
l1280934: ;
_1280936 = p_1280936;
int _1281058;
_1281058 = _1029614_1280872.e3;
int _1281059;
_1281059 = gid_y_1280911 * _1281058;
int _1281060;
_1281060 = _1281059 + gid_x_1280900;
float* idx_1281061;
idx_1281061 = _1029619_1280877 + _1281060;
float _1281062;
_1281062 = *idx_1281061;
if (_1280901) goto l1280937; else goto l1281132;
l1281132: ;
pbh_lower_1280940 = _1281090;
goto l1280938;
l1280937: ;
union variant_220130 _1265919_5856;
_1265919_5856.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5858;
_1265920_5858.e0 = 1;
_1265920_5858.e1 = _1265919_5856;
pbh_lower_1280940 = _1265920_5858;
goto l1280938;
l1280938: ;
bh_lower_1280940 = pbh_lower_1280940;
int _1280941;
_1280941 = -1 + gid_y_1280911;
bool _1280942;
_1280942 = _1280906 <= _1280941;
if (_1280942) goto l1280943; else goto l1281128;
l1281128: ;
union variant_220130 _1281129;
_1281129.qs32 = _1280941;
struct_BoundaryMode_220129 _1281130;
_1281130.e0 = 0;
_1281130.e1 = _1281129;
pbh_upper_1280946 = _1281130;
goto l1280944;
l1280943: ;
union variant_220130 _1265919_5866;
_1265919_5866.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5868;
_1265920_5868.e0 = 1;
_1265920_5868.e1 = _1265919_5866;
pbh_upper_1280946 = _1265920_5868;
goto l1280944;
l1280944: ;
bh_upper_1280946 = pbh_upper_1280946;
unsigned int _1280949;
_1280949 = bh_upper_1280946.e0;
unsigned int _1280947;
_1280947 = bh_lower_1280940.e0;
union variant_220130 _1280953;
_1280953 = bh_upper_1280946.e1;
union variant_220130 _1280956;
_1280956 = bh_lower_1280940.e1;
bool _1280950;
_1280950 = _1280949 == 0;
bool _1280948;
_1280948 = _1280947 == 0;
bool _1280951;
_1280951 = _1280948 & _1280950;
if (_1280951) goto l1280952; else goto l1281119;
l1281119: ;
bool _1281120;
_1281120 = _1280947 == 1;
if (_1281120) goto l1281121; else goto l1281123;
l1281123: ;
bool _1281124;
_1281124 = _1280949 == 1;
if (_1281124) goto l1281125; else goto l1281127;
l1281127: ;
// bottom: float r4_1265918_5880;
// bottom: p_1280965 = r4_1265918_5880;
goto l1280963;
l1281125: ;
float c_1281126;
c_1281126 = _1280953.pf32;
p_1280965 = c_1281126;
goto l1280963;
l1281121: ;
float c_1281122;
c_1281122 = _1280956.pf32;
p_1280965 = c_1281122;
goto l1280963;
l1280952: ;
int x_1280957;
x_1280957 = _1280956.qs32;
int y_1280954;
y_1280954 = _1280953.qs32;
int _1280955;
_1280955 = y_1280954 * _1280925;
int _1280958;
_1280958 = _1280955 + x_1280957;
float* idx_1280959;
idx_1280959 = _1029616_1280874 + _1280958;
_1280962 = __ldg(idx_1280959);
p_1280962 = _1280962;
l1280960: ;
_1280962 = p_1280962;
p_1280965 = _1280962;
goto l1280963;
l1280963: ;
_1280965 = p_1280965;
int _1280966;
_1280966 = -1 + gid_x_1280900;
bool _1280967;
_1280967 = _1280966 < 0;
if (_1280967) goto l1280968; else goto l1281116;
l1281116: ;
union variant_220130 _1281117;
_1281117.qs32 = _1280966;
struct_BoundaryMode_220129 _1281118;
_1281118.e0 = 0;
_1281118.e1 = _1281117;
pbh_lower_1280971 = _1281118;
goto l1280969;
l1280968: ;
union variant_220130 _1265919_5886;
_1265919_5886.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5888;
_1265920_5888.e0 = 1;
_1265920_5888.e1 = _1265919_5886;
pbh_lower_1280971 = _1265920_5888;
goto l1280969;
l1280969: ;
bh_lower_1280971 = pbh_lower_1280971;
if (_1280912) goto l1280972; else goto l1281115;
l1281115: ;
pbh_upper_1280975 = _1281102;
goto l1280973;
l1280972: ;
union variant_220130 _1265919_5892;
_1265919_5892.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5894;
_1265920_5894.e0 = 1;
_1265920_5894.e1 = _1265919_5892;
pbh_upper_1280975 = _1265920_5894;
goto l1280973;
l1280973: ;
bh_upper_1280975 = pbh_upper_1280975;
union variant_220130 _1280985;
_1280985 = bh_lower_1280971.e1;
unsigned int _1280978;
_1280978 = bh_upper_1280975.e0;
bool _1280979;
_1280979 = _1280978 == 0;
union variant_220130 _1280982;
_1280982 = bh_upper_1280975.e1;
unsigned int _1280976;
_1280976 = bh_lower_1280971.e0;
bool _1280977;
_1280977 = _1280976 == 0;
bool _1280980;
_1280980 = _1280977 & _1280979;
if (_1280980) goto l1280981; else goto l1281106;
l1281106: ;
bool _1281107;
_1281107 = _1280976 == 1;
if (_1281107) goto l1281108; else goto l1281110;
l1281110: ;
bool _1281111;
_1281111 = _1280978 == 1;
if (_1281111) goto l1281112; else goto l1281114;
l1281114: ;
// bottom: float r4_1265918_5906;
// bottom: p_1280994 = r4_1265918_5906;
goto l1280992;
l1281112: ;
float c_1281113;
c_1281113 = _1280982.pf32;
p_1280994 = c_1281113;
goto l1280992;
l1281108: ;
float c_1281109;
c_1281109 = _1280985.pf32;
p_1280994 = c_1281109;
goto l1280992;
l1280981: ;
int x_1280986;
x_1280986 = _1280985.qs32;
int y_1280983;
y_1280983 = _1280982.qs32;
int _1280984;
_1280984 = y_1280983 * _1280925;
int _1280987;
_1280987 = _1280984 + x_1280986;
float* idx_1280988;
idx_1280988 = _1029616_1280874 + _1280987;
_1280991 = __ldg(idx_1280988);
p_1280991 = _1280991;
l1280989: ;
_1280991 = p_1280991;
p_1280994 = _1280991;
goto l1280992;
l1280992: ;
_1280994 = p_1280994;
int _1280995;
_1280995 = 1 + gid_x_1280900;
bool _1280996;
_1280996 = _1280995 < 0;
if (_1280996) goto l1280997; else goto l1281103;
l1281103: ;
union variant_220130 _1281104;
_1281104.qs32 = _1280995;
struct_BoundaryMode_220129 _1281105;
_1281105.e0 = 0;
_1281105.e1 = _1281104;
pbh_lower_1281000 = _1281105;
goto l1280998;
l1280997: ;
union variant_220130 _1265919_5912;
_1265919_5912.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5914;
_1265920_5914.e0 = 1;
_1265920_5914.e1 = _1265919_5912;
pbh_lower_1281000 = _1265920_5914;
goto l1280998;
l1280998: ;
bh_lower_1281000 = pbh_lower_1281000;
if (_1280912) goto l1281001; else goto l1281100;
l1281100: ;
pbh_upper_1281004 = _1281102;
goto l1281002;
l1281001: ;
union variant_220130 _1265919_5918;
_1265919_5918.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5920;
_1265920_5920.e0 = 1;
_1265920_5920.e1 = _1265919_5918;
pbh_upper_1281004 = _1265920_5920;
goto l1281002;
l1281002: ;
bh_upper_1281004 = pbh_upper_1281004;
unsigned int _1281007;
_1281007 = bh_upper_1281004.e0;
unsigned int _1281005;
_1281005 = bh_lower_1281000.e0;
bool _1281006;
_1281006 = _1281005 == 0;
union variant_220130 _1281014;
_1281014 = bh_lower_1281000.e1;
union variant_220130 _1281011;
_1281011 = bh_upper_1281004.e1;
bool _1281008;
_1281008 = _1281007 == 0;
bool _1281009;
_1281009 = _1281006 & _1281008;
if (_1281009) goto l1281010; else goto l1281091;
l1281091: ;
bool _1281092;
_1281092 = _1281005 == 1;
if (_1281092) goto l1281093; else goto l1281095;
l1281095: ;
bool _1281096;
_1281096 = _1281007 == 1;
if (_1281096) goto l1281097; else goto l1281099;
l1281099: ;
// bottom: float r4_1265918_5932;
// bottom: p_1281023 = r4_1265918_5932;
goto l1281021;
l1281097: ;
float c_1281098;
c_1281098 = _1281011.pf32;
p_1281023 = c_1281098;
goto l1281021;
l1281093: ;
float c_1281094;
c_1281094 = _1281014.pf32;
p_1281023 = c_1281094;
goto l1281021;
l1281010: ;
int y_1281012;
y_1281012 = _1281011.qs32;
int _1281013;
_1281013 = y_1281012 * _1280925;
int x_1281015;
x_1281015 = _1281014.qs32;
int _1281016;
_1281016 = _1281013 + x_1281015;
float* idx_1281017;
idx_1281017 = _1029616_1280874 + _1281016;
_1281020 = __ldg(idx_1281017);
p_1281020 = _1281020;
l1281018: ;
_1281020 = p_1281020;
p_1281023 = _1281020;
goto l1281021;
l1281021: ;
_1281023 = p_1281023;
if (_1280901) goto l1281024; else goto l1281088;
l1281088: ;
pbh_lower_1281027 = _1281090;
goto l1281025;
l1281024: ;
union variant_220130 _1265919_5933;
_1265919_5933.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5935;
_1265920_5935.e0 = 1;
_1265920_5935.e1 = _1265919_5933;
pbh_lower_1281027 = _1265920_5935;
goto l1281025;
l1281025: ;
bh_lower_1281027 = pbh_lower_1281027;
int _1281028;
_1281028 = 1 + gid_y_1280911;
bool _1281029;
_1281029 = _1280906 <= _1281028;
if (_1281029) goto l1281030; else goto l1281085;
l1281085: ;
union variant_220130 _1281086;
_1281086.qs32 = _1281028;
struct_BoundaryMode_220129 _1281087;
_1281087.e0 = 0;
_1281087.e1 = _1281086;
pbh_upper_1281033 = _1281087;
goto l1281031;
l1281030: ;
union variant_220130 _1265919_5943;
_1265919_5943.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5945;
_1265920_5945.e0 = 1;
_1265920_5945.e1 = _1265919_5943;
pbh_upper_1281033 = _1265920_5945;
goto l1281031;
l1281031: ;
bh_upper_1281033 = pbh_upper_1281033;
unsigned int _1281036;
_1281036 = bh_upper_1281033.e0;
unsigned int _1281034;
_1281034 = bh_lower_1281027.e0;
union variant_220130 _1281043;
_1281043 = bh_lower_1281027.e1;
bool _1281037;
_1281037 = _1281036 == 0;
bool _1281035;
_1281035 = _1281034 == 0;
union variant_220130 _1281040;
_1281040 = bh_upper_1281033.e1;
bool _1281038;
_1281038 = _1281035 & _1281037;
if (_1281038) goto l1281039; else goto l1281076;
l1281076: ;
bool _1281077;
_1281077 = _1281034 == 1;
if (_1281077) goto l1281078; else goto l1281080;
l1281080: ;
bool _1281081;
_1281081 = _1281036 == 1;
if (_1281081) goto l1281082; else goto l1281084;
l1281084: ;
// bottom: float r4_1265918_5957;
// bottom: p_1281052 = r4_1265918_5957;
goto l1281050;
l1281082: ;
float c_1281083;
c_1281083 = _1281040.pf32;
p_1281052 = c_1281083;
goto l1281050;
l1281078: ;
float c_1281079;
c_1281079 = _1281043.pf32;
p_1281052 = c_1281079;
goto l1281050;
l1281039: ;
int x_1281044;
x_1281044 = _1281043.qs32;
int y_1281041;
y_1281041 = _1281040.qs32;
int _1281042;
_1281042 = y_1281041 * _1280925;
int _1281045;
_1281045 = _1281042 + x_1281044;
float* idx_1281046;
idx_1281046 = _1029616_1280874 + _1281045;
_1281049 = __ldg(idx_1281046);
p_1281049 = _1281049;
l1281047: ;
_1281049 = p_1281049;
p_1281052 = _1281049;
goto l1281050;
l1281050: ;
_1281052 = p_1281052;
float _1281068;
_1281068 = 2.500000e-01f * _1280994;
float _1281063;
_1281063 = _1281062;
float _1281057;
_1281057 = 2.000000e-01f * _1280936;
float _1281072;
_1281072 = 2.500000e-01f * _1281052;
float _1281066;
_1281066 = 2.500000e-01f * _1280965;
float _1281064;
_1281064 = 2.000000e-01f * _1281063;
float _1281065;
_1281065 = _1281057 + _1281064;
float _1281070;
_1281070 = 2.500000e-01f * _1281023;
int _1281053;
_1281053 = _1029618_1280876.e3;
float _1281067;
_1281067 = 0.000000e+00f + _1281066;
int _1281054;
_1281054 = gid_y_1280911 * _1281053;
float _1281069;
_1281069 = _1281067 + _1281068;
int _1281055;
_1281055 = _1281054 + gid_x_1280900;
float _1281071;
_1281071 = _1281069 + _1281070;
float* idx_1281056;
idx_1281056 = _1029615_1280873 + _1281055;
float _1281073;
_1281073 = _1281071 + _1281072;
float val_1281074;
val_1281074 = _1281065 + _1281073;
*idx_1281056 = val_1281074;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1028609(struct_Img_220118 _1028612_1280013, float* _1028613_1280014, float* _1028614_1280015, struct_Img_220118 _1028615_1280016, struct_Img_220118 _1028616_1280017, float* _1028617_1280018) {
int _1280021;
int p_1280021;
int _1280024;
int p_1280024;
int _1280027;
int p_1280027;
int _1280030;
int p_1280030;
int _1280033;
int p_1280033;
int _1280036;
int p_1280036;
int _1280039;
int p_1280039;
struct_BoundaryMode_220129 bh_lower_1280046;
struct_BoundaryMode_220129 pbh_lower_1280046;
struct_BoundaryMode_220129 bh_lower_1280053;
struct_BoundaryMode_220129 pbh_lower_1280053;
float _1280070;
float p_1280070;
float _1280073;
float p_1280073;
struct_BoundaryMode_220129 bh_lower_1280077;
struct_BoundaryMode_220129 pbh_lower_1280077;
struct_BoundaryMode_220129 bh_lower_1280083;
struct_BoundaryMode_220129 pbh_lower_1280083;
float _1280099;
float p_1280099;
float _1280102;
float p_1280102;
struct_BoundaryMode_220129 bh_lower_1280108;
struct_BoundaryMode_220129 pbh_lower_1280108;
struct_BoundaryMode_220129 bh_lower_1280112;
struct_BoundaryMode_220129 pbh_lower_1280112;
float _1280128;
float p_1280128;
float _1280131;
float p_1280131;
struct_BoundaryMode_220129 bh_lower_1280137;
struct_BoundaryMode_220129 pbh_lower_1280137;
struct_BoundaryMode_220129 bh_lower_1280141;
struct_BoundaryMode_220129 pbh_lower_1280141;
float _1280157;
float p_1280157;
float _1280160;
float p_1280160;
struct_BoundaryMode_220129 bh_lower_1280164;
struct_BoundaryMode_220129 pbh_lower_1280164;
struct_BoundaryMode_220129 bh_lower_1280170;
struct_BoundaryMode_220129 pbh_lower_1280170;
float _1280186;
float p_1280186;
float _1280189;
float p_1280189;
_1280021 = threadIdx_x();
p_1280021 = _1280021;
l1280019: ;
_1280021 = p_1280021;
_1280024 = blockDim_x();
p_1280024 = _1280024;
l1280022: ;
_1280024 = p_1280024;
_1280027 = blockIdx_x();
p_1280027 = _1280027;
l1280025: ;
_1280027 = p_1280027;
_1280030 = threadIdx_y();
p_1280030 = _1280030;
l1280028: ;
_1280030 = p_1280030;
_1280033 = blockDim_y();
p_1280033 = _1280033;
l1280031: ;
_1280033 = p_1280033;
_1280036 = blockIdx_y();
p_1280036 = _1280036;
l1280034: ;
_1280036 = p_1280036;
_1280039 = blockDim_y();
p_1280039 = _1280039;
l1280037: ;
_1280039 = p_1280039;
int _1280040;
_1280040 = _1280024 * _1280027;
int gid_x_1280041;
gid_x_1280041 = _1280021 + _1280040;
bool _1280042;
_1280042 = gid_x_1280041 < 0;
union variant_220130 _1280226;
_1280226.qs32 = gid_x_1280041;
struct_BoundaryMode_220129 _1280227;
_1280227.e0 = 0;
_1280227.e1 = _1280226;
if (_1280042) goto l1280043; else goto l1280280;
l1280280: ;
pbh_lower_1280046 = _1280227;
goto l1280044;
l1280043: ;
union variant_220130 _1265919_5970;
_1265919_5970.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5972;
_1265920_5972.e0 = 1;
_1265920_5972.e1 = _1265919_5970;
pbh_lower_1280046 = _1265920_5972;
goto l1280044;
l1280044: ;
bh_lower_1280046 = pbh_lower_1280046;
int _1280047;
_1280047 = _1280033 * _1280036;
int gid_y_1280048;
gid_y_1280048 = _1280030 + _1280047;
union variant_220130 _1280238;
_1280238.qs32 = gid_y_1280048;
bool _1280049;
_1280049 = gid_y_1280048 < 0;
struct_BoundaryMode_220129 _1280239;
_1280239.e0 = 0;
_1280239.e1 = _1280238;
if (_1280049) goto l1280050; else goto l1280279;
l1280279: ;
pbh_lower_1280053 = _1280239;
goto l1280051;
l1280050: ;
union variant_220130 _1265919_5980;
_1265919_5980.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5982;
_1265920_5982.e0 = 1;
_1265920_5982.e1 = _1265919_5980;
pbh_lower_1280053 = _1265920_5982;
goto l1280051;
l1280051: ;
bh_lower_1280053 = pbh_lower_1280053;
unsigned int _1280056;
_1280056 = bh_lower_1280053.e0;
union variant_220130 _1280060;
_1280060 = bh_lower_1280053.e1;
union variant_220130 _1280064;
_1280064 = bh_lower_1280046.e1;
unsigned int _1280054;
_1280054 = bh_lower_1280046.e0;
int _1280062;
_1280062 = _1028615_1280016.e3;
bool _1280057;
_1280057 = _1280056 == 0;
bool _1280055;
_1280055 = _1280054 == 0;
bool _1280058;
_1280058 = _1280055 & _1280057;
if (_1280058) goto l1280059; else goto l1280270;
l1280270: ;
bool _1280271;
_1280271 = _1280054 == 1;
if (_1280271) goto l1280272; else goto l1280274;
l1280274: ;
bool _1280275;
_1280275 = _1280056 == 1;
if (_1280275) goto l1280276; else goto l1280278;
l1280278: ;
// bottom: float r4_1265918_5995;
// bottom: p_1280073 = r4_1265918_5995;
goto l1280071;
l1280276: ;
float c_1280277;
c_1280277 = _1280060.pf32;
p_1280073 = c_1280277;
goto l1280071;
l1280272: ;
float c_1280273;
c_1280273 = _1280064.pf32;
p_1280073 = c_1280273;
goto l1280071;
l1280059: ;
int x_1280065;
x_1280065 = _1280064.qs32;
int y_1280061;
y_1280061 = _1280060.qs32;
int _1280063;
_1280063 = y_1280061 * _1280062;
int _1280066;
_1280066 = _1280063 + x_1280065;
float* idx_1280067;
idx_1280067 = _1028614_1280015 + _1280066;
_1280070 = __ldg(idx_1280067);
p_1280070 = _1280070;
l1280068: ;
_1280070 = p_1280070;
p_1280073 = _1280070;
goto l1280071;
l1280071: ;
_1280073 = p_1280073;
int _1280195;
_1280195 = _1028612_1280013.e3;
int _1280196;
_1280196 = gid_y_1280048 * _1280195;
int _1280197;
_1280197 = _1280196 + gid_x_1280041;
float* idx_1280198;
idx_1280198 = _1028617_1280018 + _1280197;
float _1280199;
_1280199 = *idx_1280198;
if (_1280042) goto l1280074; else goto l1280269;
l1280269: ;
pbh_lower_1280077 = _1280227;
goto l1280075;
l1280074: ;
union variant_220130 _1265919_5997;
_1265919_5997.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_5999;
_1265920_5999.e0 = 1;
_1265920_5999.e1 = _1265919_5997;
pbh_lower_1280077 = _1265920_5999;
goto l1280075;
l1280075: ;
bh_lower_1280077 = pbh_lower_1280077;
int _1280078;
_1280078 = -1 + gid_y_1280048;
bool _1280079;
_1280079 = _1280078 < 0;
if (_1280079) goto l1280080; else goto l1280265;
l1280265: ;
union variant_220130 _1280266;
_1280266.qs32 = _1280078;
struct_BoundaryMode_220129 _1280267;
_1280267.e0 = 0;
_1280267.e1 = _1280266;
pbh_lower_1280083 = _1280267;
goto l1280081;
l1280080: ;
union variant_220130 _1265919_6008;
_1265919_6008.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6010;
_1265920_6010.e0 = 1;
_1265920_6010.e1 = _1265919_6008;
pbh_lower_1280083 = _1265920_6010;
goto l1280081;
l1280081: ;
bh_lower_1280083 = pbh_lower_1280083;
unsigned int _1280086;
_1280086 = bh_lower_1280083.e0;
union variant_220130 _1280093;
_1280093 = bh_lower_1280077.e1;
unsigned int _1280084;
_1280084 = bh_lower_1280077.e0;
union variant_220130 _1280090;
_1280090 = bh_lower_1280083.e1;
bool _1280087;
_1280087 = _1280086 == 0;
bool _1280085;
_1280085 = _1280084 == 0;
bool _1280088;
_1280088 = _1280085 & _1280087;
if (_1280088) goto l1280089; else goto l1280256;
l1280256: ;
bool _1280257;
_1280257 = _1280084 == 1;
if (_1280257) goto l1280258; else goto l1280260;
l1280260: ;
bool _1280261;
_1280261 = _1280086 == 1;
if (_1280261) goto l1280262; else goto l1280264;
l1280264: ;
// bottom: float r4_1265918_6022;
// bottom: p_1280102 = r4_1265918_6022;
goto l1280100;
l1280262: ;
float c_1280263;
c_1280263 = _1280090.pf32;
p_1280102 = c_1280263;
goto l1280100;
l1280258: ;
float c_1280259;
c_1280259 = _1280093.pf32;
p_1280102 = c_1280259;
goto l1280100;
l1280089: ;
int x_1280094;
x_1280094 = _1280093.qs32;
int y_1280091;
y_1280091 = _1280090.qs32;
int _1280092;
_1280092 = y_1280091 * _1280062;
int _1280095;
_1280095 = _1280092 + x_1280094;
float* idx_1280096;
idx_1280096 = _1028614_1280015 + _1280095;
_1280099 = __ldg(idx_1280096);
p_1280099 = _1280099;
l1280097: ;
_1280099 = p_1280099;
p_1280102 = _1280099;
goto l1280100;
l1280100: ;
_1280102 = p_1280102;
int _1280103;
_1280103 = -1 + gid_x_1280041;
bool _1280104;
_1280104 = _1280103 < 0;
if (_1280104) goto l1280105; else goto l1280253;
l1280253: ;
union variant_220130 _1280254;
_1280254.qs32 = _1280103;
struct_BoundaryMode_220129 _1280255;
_1280255.e0 = 0;
_1280255.e1 = _1280254;
pbh_lower_1280108 = _1280255;
goto l1280106;
l1280105: ;
union variant_220130 _1265919_6028;
_1265919_6028.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6030;
_1265920_6030.e0 = 1;
_1265920_6030.e1 = _1265919_6028;
pbh_lower_1280108 = _1265920_6030;
goto l1280106;
l1280106: ;
bh_lower_1280108 = pbh_lower_1280108;
if (_1280049) goto l1280109; else goto l1280252;
l1280252: ;
pbh_lower_1280112 = _1280239;
goto l1280110;
l1280109: ;
union variant_220130 _1265919_6034;
_1265919_6034.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6036;
_1265920_6036.e0 = 1;
_1265920_6036.e1 = _1265919_6034;
pbh_lower_1280112 = _1265920_6036;
goto l1280110;
l1280110: ;
bh_lower_1280112 = pbh_lower_1280112;
unsigned int _1280113;
_1280113 = bh_lower_1280108.e0;
unsigned int _1280115;
_1280115 = bh_lower_1280112.e0;
union variant_220130 _1280122;
_1280122 = bh_lower_1280108.e1;
bool _1280114;
_1280114 = _1280113 == 0;
union variant_220130 _1280119;
_1280119 = bh_lower_1280112.e1;
bool _1280116;
_1280116 = _1280115 == 0;
bool _1280117;
_1280117 = _1280114 & _1280116;
if (_1280117) goto l1280118; else goto l1280243;
l1280243: ;
bool _1280244;
_1280244 = _1280113 == 1;
if (_1280244) goto l1280245; else goto l1280247;
l1280247: ;
bool _1280248;
_1280248 = _1280115 == 1;
if (_1280248) goto l1280249; else goto l1280251;
l1280251: ;
// bottom: float r4_1265918_6048;
// bottom: p_1280131 = r4_1265918_6048;
goto l1280129;
l1280249: ;
float c_1280250;
c_1280250 = _1280119.pf32;
p_1280131 = c_1280250;
goto l1280129;
l1280245: ;
float c_1280246;
c_1280246 = _1280122.pf32;
p_1280131 = c_1280246;
goto l1280129;
l1280118: ;
int x_1280123;
x_1280123 = _1280122.qs32;
int y_1280120;
y_1280120 = _1280119.qs32;
int _1280121;
_1280121 = y_1280120 * _1280062;
int _1280124;
_1280124 = _1280121 + x_1280123;
float* idx_1280125;
idx_1280125 = _1028614_1280015 + _1280124;
_1280128 = __ldg(idx_1280125);
p_1280128 = _1280128;
l1280126: ;
_1280128 = p_1280128;
p_1280131 = _1280128;
goto l1280129;
l1280129: ;
_1280131 = p_1280131;
int _1280132;
_1280132 = 1 + gid_x_1280041;
bool _1280133;
_1280133 = _1280132 < 0;
if (_1280133) goto l1280134; else goto l1280240;
l1280240: ;
union variant_220130 _1280241;
_1280241.qs32 = _1280132;
struct_BoundaryMode_220129 _1280242;
_1280242.e0 = 0;
_1280242.e1 = _1280241;
pbh_lower_1280137 = _1280242;
goto l1280135;
l1280134: ;
union variant_220130 _1265919_6054;
_1265919_6054.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6056;
_1265920_6056.e0 = 1;
_1265920_6056.e1 = _1265919_6054;
pbh_lower_1280137 = _1265920_6056;
goto l1280135;
l1280135: ;
bh_lower_1280137 = pbh_lower_1280137;
if (_1280049) goto l1280138; else goto l1280237;
l1280237: ;
pbh_lower_1280141 = _1280239;
goto l1280139;
l1280138: ;
union variant_220130 _1265919_6060;
_1265919_6060.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6062;
_1265920_6062.e0 = 1;
_1265920_6062.e1 = _1265919_6060;
pbh_lower_1280141 = _1265920_6062;
goto l1280139;
l1280139: ;
bh_lower_1280141 = pbh_lower_1280141;
union variant_220130 _1280148;
_1280148 = bh_lower_1280141.e1;
unsigned int _1280144;
_1280144 = bh_lower_1280141.e0;
unsigned int _1280142;
_1280142 = bh_lower_1280137.e0;
bool _1280145;
_1280145 = _1280144 == 0;
union variant_220130 _1280151;
_1280151 = bh_lower_1280137.e1;
bool _1280143;
_1280143 = _1280142 == 0;
bool _1280146;
_1280146 = _1280143 & _1280145;
if (_1280146) goto l1280147; else goto l1280228;
l1280228: ;
bool _1280229;
_1280229 = _1280142 == 1;
if (_1280229) goto l1280230; else goto l1280232;
l1280232: ;
bool _1280233;
_1280233 = _1280144 == 1;
if (_1280233) goto l1280234; else goto l1280236;
l1280236: ;
// bottom: float r4_1265918_6074;
// bottom: p_1280160 = r4_1265918_6074;
goto l1280158;
l1280234: ;
float c_1280235;
c_1280235 = _1280148.pf32;
p_1280160 = c_1280235;
goto l1280158;
l1280230: ;
float c_1280231;
c_1280231 = _1280151.pf32;
p_1280160 = c_1280231;
goto l1280158;
l1280147: ;
int y_1280149;
y_1280149 = _1280148.qs32;
int _1280150;
_1280150 = y_1280149 * _1280062;
int x_1280152;
x_1280152 = _1280151.qs32;
int _1280153;
_1280153 = _1280150 + x_1280152;
float* idx_1280154;
idx_1280154 = _1028614_1280015 + _1280153;
_1280157 = __ldg(idx_1280154);
p_1280157 = _1280157;
l1280155: ;
_1280157 = p_1280157;
p_1280160 = _1280157;
goto l1280158;
l1280158: ;
_1280160 = p_1280160;
if (_1280042) goto l1280161; else goto l1280225;
l1280225: ;
pbh_lower_1280164 = _1280227;
goto l1280162;
l1280161: ;
union variant_220130 _1265919_6075;
_1265919_6075.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6077;
_1265920_6077.e0 = 1;
_1265920_6077.e1 = _1265919_6075;
pbh_lower_1280164 = _1265920_6077;
goto l1280162;
l1280162: ;
bh_lower_1280164 = pbh_lower_1280164;
int _1280165;
_1280165 = 1 + gid_y_1280048;
bool _1280166;
_1280166 = _1280165 < 0;
if (_1280166) goto l1280167; else goto l1280222;
l1280222: ;
union variant_220130 _1280223;
_1280223.qs32 = _1280165;
struct_BoundaryMode_220129 _1280224;
_1280224.e0 = 0;
_1280224.e1 = _1280223;
pbh_lower_1280170 = _1280224;
goto l1280168;
l1280167: ;
union variant_220130 _1265919_6086;
_1265919_6086.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6088;
_1265920_6088.e0 = 1;
_1265920_6088.e1 = _1265919_6086;
pbh_lower_1280170 = _1265920_6088;
goto l1280168;
l1280168: ;
bh_lower_1280170 = pbh_lower_1280170;
union variant_220130 _1280180;
_1280180 = bh_lower_1280164.e1;
unsigned int _1280173;
_1280173 = bh_lower_1280170.e0;
unsigned int _1280171;
_1280171 = bh_lower_1280164.e0;
union variant_220130 _1280177;
_1280177 = bh_lower_1280170.e1;
bool _1280174;
_1280174 = _1280173 == 0;
bool _1280172;
_1280172 = _1280171 == 0;
bool _1280175;
_1280175 = _1280172 & _1280174;
if (_1280175) goto l1280176; else goto l1280213;
l1280213: ;
bool _1280214;
_1280214 = _1280171 == 1;
if (_1280214) goto l1280215; else goto l1280217;
l1280217: ;
bool _1280218;
_1280218 = _1280173 == 1;
if (_1280218) goto l1280219; else goto l1280221;
l1280221: ;
// bottom: float r4_1265918_6100;
// bottom: p_1280189 = r4_1265918_6100;
goto l1280187;
l1280219: ;
float c_1280220;
c_1280220 = _1280177.pf32;
p_1280189 = c_1280220;
goto l1280187;
l1280215: ;
float c_1280216;
c_1280216 = _1280180.pf32;
p_1280189 = c_1280216;
goto l1280187;
l1280176: ;
int x_1280181;
x_1280181 = _1280180.qs32;
int y_1280178;
y_1280178 = _1280177.qs32;
int _1280179;
_1280179 = y_1280178 * _1280062;
int _1280182;
_1280182 = _1280179 + x_1280181;
float* idx_1280183;
idx_1280183 = _1028614_1280015 + _1280182;
_1280186 = __ldg(idx_1280183);
p_1280186 = _1280186;
l1280184: ;
_1280186 = p_1280186;
p_1280189 = _1280186;
goto l1280187;
l1280187: ;
_1280189 = p_1280189;
int _1280190;
_1280190 = _1028616_1280017.e3;
float _1280209;
_1280209 = 2.500000e-01f * _1280189;
float _1280200;
_1280200 = _1280199;
float _1280201;
_1280201 = 2.000000e-01f * _1280200;
int _1280191;
_1280191 = gid_y_1280048 * _1280190;
float _1280205;
_1280205 = 2.500000e-01f * _1280131;
float _1280207;
_1280207 = 2.500000e-01f * _1280160;
float _1280194;
_1280194 = 2.000000e-01f * _1280073;
float _1280203;
_1280203 = 2.500000e-01f * _1280102;
float _1280202;
_1280202 = _1280194 + _1280201;
int _1280192;
_1280192 = _1280191 + gid_x_1280041;
float _1280204;
_1280204 = 0.000000e+00f + _1280203;
float* idx_1280193;
idx_1280193 = _1028613_1280014 + _1280192;
float _1280206;
_1280206 = _1280204 + _1280205;
float _1280208;
_1280208 = _1280206 + _1280207;
float _1280210;
_1280210 = _1280208 + _1280209;
float val_1280211;
val_1280211 = _1280202 + _1280210;
*idx_1280193 = val_1280211;
return ;
}
__global__ __launch_bounds__ (64 * 2 * 1) void lambda_1008735(float* _1008738_1281294, struct_Img_220118 _1008739_1281295, float* _1008740_1281296, struct_Img_220118 _1008741_1281297, float* _1008742_1281298, struct_Img_220118 _1008743_1281299) {
int tid_x_1281302;
int ptid_x_1281302;
int tid_y_1281305;
int ptid_y_1281305;
int threadIdx_y_1281308;
int pthreadIdx_y_1281308;
int blockDim_y_1281311;
int pblockDim_y_1281311;
int blockIdx_y_1281314;
int pblockIdx_y_1281314;
float* spm_1281317;
float* pspm_1281317;
int _1281320;
int p_1281320;
int _1281323;
int p_1281323;
int _1281326;
int p_1281326;
int _1281329;
int p_1281329;
int _1281332;
int p_1281332;
int _1281335;
int p_1281335;
int _1281338;
int p_1281338;
int _1281341;
int p_1281341;
struct_BoundaryMode_220129 bh_lower_1281348;
struct_BoundaryMode_220129 pbh_lower_1281348;
struct_BoundaryMode_220129 map_boundary_mode_1281359;
struct_BoundaryMode_220129 pmap_boundary_mode_1281359;
struct_BoundaryMode_220129 map_boundary_mode_1281362;
struct_BoundaryMode_220129 pmap_boundary_mode_1281362;
struct_BoundaryMode_220129 bh_lower_1281370;
struct_BoundaryMode_220129 pbh_lower_1281370;
struct_BoundaryMode_220129 map_boundary_mode_1281381;
struct_BoundaryMode_220129 pmap_boundary_mode_1281381;
struct_BoundaryMode_220129 map_boundary_mode_1281384;
struct_BoundaryMode_220129 pmap_boundary_mode_1281384;
float _1281401;
float p_1281401;
float _1281404;
float p_1281404;
struct_BoundaryMode_220129 bh_lower_1281410;
struct_BoundaryMode_220129 pbh_lower_1281410;
struct_BoundaryMode_220129 map_boundary_mode_1281420;
struct_BoundaryMode_220129 pmap_boundary_mode_1281420;
struct_BoundaryMode_220129 map_boundary_mode_1281423;
struct_BoundaryMode_220129 pmap_boundary_mode_1281423;
struct_BoundaryMode_220129 bh_lower_1281428;
struct_BoundaryMode_220129 pbh_lower_1281428;
struct_BoundaryMode_220129 map_boundary_mode_1281438;
struct_BoundaryMode_220129 pmap_boundary_mode_1281438;
struct_BoundaryMode_220129 map_boundary_mode_1281441;
struct_BoundaryMode_220129 pmap_boundary_mode_1281441;
float _1281457;
float p_1281457;
float _1281460;
float p_1281460;
struct_BoundaryMode_220129 bh_lower_1281464;
struct_BoundaryMode_220129 pbh_lower_1281464;
struct_BoundaryMode_220129 map_boundary_mode_1281474;
struct_BoundaryMode_220129 pmap_boundary_mode_1281474;
struct_BoundaryMode_220129 map_boundary_mode_1281477;
struct_BoundaryMode_220129 pmap_boundary_mode_1281477;
struct_BoundaryMode_220129 bh_lower_1281481;
struct_BoundaryMode_220129 pbh_lower_1281481;
struct_BoundaryMode_220129 map_boundary_mode_1281491;
struct_BoundaryMode_220129 pmap_boundary_mode_1281491;
struct_BoundaryMode_220129 map_boundary_mode_1281494;
struct_BoundaryMode_220129 pmap_boundary_mode_1281494;
float _1281510;
float p_1281510;
float _1281513;
float p_1281513;
struct_BoundaryMode_220129 bh_lower_1281519;
struct_BoundaryMode_220129 pbh_lower_1281519;
struct_BoundaryMode_220129 map_boundary_mode_1281529;
struct_BoundaryMode_220129 pmap_boundary_mode_1281529;
struct_BoundaryMode_220129 map_boundary_mode_1281532;
struct_BoundaryMode_220129 pmap_boundary_mode_1281532;
struct_BoundaryMode_220129 bh_lower_1281536;
struct_BoundaryMode_220129 pbh_lower_1281536;
struct_BoundaryMode_220129 map_boundary_mode_1281546;
struct_BoundaryMode_220129 pmap_boundary_mode_1281546;
struct_BoundaryMode_220129 map_boundary_mode_1281549;
struct_BoundaryMode_220129 pmap_boundary_mode_1281549;
float _1281565;
float p_1281565;
float _1281568;
float p_1281568;
struct_BoundaryMode_220129 bh_lower_1281572;
struct_BoundaryMode_220129 pbh_lower_1281572;
struct_BoundaryMode_220129 map_boundary_mode_1281582;
struct_BoundaryMode_220129 pmap_boundary_mode_1281582;
struct_BoundaryMode_220129 map_boundary_mode_1281585;
struct_BoundaryMode_220129 pmap_boundary_mode_1281585;
struct_BoundaryMode_220129 bh_lower_1281591;
struct_BoundaryMode_220129 pbh_lower_1281591;
struct_BoundaryMode_220129 map_boundary_mode_1281601;
struct_BoundaryMode_220129 pmap_boundary_mode_1281601;
struct_BoundaryMode_220129 map_boundary_mode_1281604;
struct_BoundaryMode_220129 pmap_boundary_mode_1281604;
float _1281620;
float p_1281620;
float _1281623;
float p_1281623;
int _1281660;
int p_1281660;
int _1281663;
int p_1281663;
int _1281666;
int p_1281666;
int _1281669;
int p_1281669;
tid_x_1281302 = threadIdx_x();
ptid_x_1281302 = tid_x_1281302;
l1281300: ;
tid_x_1281302 = ptid_x_1281302;
tid_y_1281305 = threadIdx_y();
ptid_y_1281305 = tid_y_1281305;
l1281303: ;
tid_y_1281305 = ptid_y_1281305;
threadIdx_y_1281308 = threadIdx_y();
pthreadIdx_y_1281308 = threadIdx_y_1281308;
l1281306: ;
threadIdx_y_1281308 = pthreadIdx_y_1281308;
blockDim_y_1281311 = blockDim_y();
pblockDim_y_1281311 = blockDim_y_1281311;
l1281309: ;
blockDim_y_1281311 = pblockDim_y_1281311;
blockIdx_y_1281314 = blockIdx_y();
pblockIdx_y_1281314 = blockIdx_y_1281314;
l1281312: ;
blockIdx_y_1281314 = pblockIdx_y_1281314;
__shared__ float reserver_spm_1281317[128];
pspm_1281317 = reserver_spm_1281317;
l1281315: ;
spm_1281317 = pspm_1281317;
_1281320 = blockDim_x();
p_1281320 = _1281320;
l1281318: ;
_1281320 = p_1281320;
_1281323 = blockIdx_x();
p_1281323 = _1281323;
l1281321: ;
_1281323 = p_1281323;
_1281326 = blockDim_y();
p_1281326 = _1281326;
l1281324: ;
_1281326 = p_1281326;
_1281329 = blockIdx_y();
p_1281329 = _1281329;
l1281327: ;
_1281329 = p_1281329;
_1281332 = blockDim_x();
p_1281332 = _1281332;
l1281330: ;
_1281332 = p_1281332;
_1281335 = blockIdx_x();
p_1281335 = _1281335;
l1281333: ;
_1281335 = p_1281335;
_1281338 = blockDim_y();
p_1281338 = _1281338;
l1281336: ;
_1281338 = p_1281338;
_1281341 = blockIdx_y();
p_1281341 = _1281341;
l1281339: ;
_1281341 = p_1281341;
int _1281629;
_1281629 = _1008743_1281299.e3;
int _1281627;
_1281627 = _1281326 * _1281329;
int _1281342;
_1281342 = _1281332 * _1281335;
int _1281343;
_1281343 = tid_x_1281302 + _1281342;
union variant_220130 _1281733;
_1281733.qs32 = _1281343;
bool _1281344;
_1281344 = _1281343 < 0;
struct_BoundaryMode_220129 _1281734;
_1281734.e0 = 0;
_1281734.e1 = _1281733;
int _1281628;
_1281628 = tid_y_1281305 + _1281627;
int _1281632;
_1281632 = _1281320 * _1281323;
int _1281630;
_1281630 = _1281628 * _1281629;
int _1281631;
_1281631 = _1281630 + tid_x_1281302;
int _1281633;
_1281633 = _1281631 + _1281632;
float* idx_1281634;
idx_1281634 = _1008738_1281294 + _1281633;
float _1281635;
_1281635 = *idx_1281634;
if (_1281344) goto l1281345; else goto l1281819;
l1281819: ;
pbh_lower_1281348 = _1281734;
goto l1281346;
l1281345: ;
union variant_220130 _1265919_6115;
_1265919_6115.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6117;
_1265920_6117.e0 = 1;
_1265920_6117.e1 = _1265919_6115;
pbh_lower_1281348 = _1265920_6117;
goto l1281346;
l1281346: ;
bh_lower_1281348 = pbh_lower_1281348;
unsigned int _1281349;
_1281349 = bh_lower_1281348.e0;
bool _1281350;
_1281350 = _1281349 == 0;
int _1281352;
_1281352 = _1008741_1281297.e1;
if (_1281350) goto l1281351; else goto l1281817;
l1281817: ;
pmap_boundary_mode_1281362 = bh_lower_1281348;
goto l1281360;
l1281351: ;
union variant_220130 _1281353;
_1281353 = bh_lower_1281348.e1;
int idx_1281354;
idx_1281354 = _1281353.qs32;
bool _1281355;
_1281355 = _1281352 <= idx_1281354;
if (_1281355) goto l1281356; else goto l1281814;
l1281814: ;
union variant_220130 _1281815;
_1281815.qs32 = idx_1281354;
struct_BoundaryMode_220129 _1281816;
_1281816.e0 = 0;
_1281816.e1 = _1281815;
pmap_boundary_mode_1281359 = _1281816;
goto l1281357;
l1281356: ;
union variant_220130 _1265919_6128;
_1265919_6128.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6130;
_1265920_6130.e0 = 1;
_1265920_6130.e1 = _1265919_6128;
pmap_boundary_mode_1281359 = _1265920_6130;
goto l1281357;
l1281357: ;
map_boundary_mode_1281359 = pmap_boundary_mode_1281359;
pmap_boundary_mode_1281362 = map_boundary_mode_1281359;
goto l1281360;
l1281360: ;
map_boundary_mode_1281362 = pmap_boundary_mode_1281362;
int _1281363;
_1281363 = _1281338 * _1281341;
int _1281364;
_1281364 = tid_y_1281305 + _1281363;
int _1281365;
_1281365 = -1 + _1281364;
bool _1281366;
_1281366 = _1281365 < 0;
if (_1281366) goto l1281367; else goto l1281811;
l1281811: ;
union variant_220130 _1281812;
_1281812.qs32 = _1281365;
struct_BoundaryMode_220129 _1281813;
_1281813.e0 = 0;
_1281813.e1 = _1281812;
pbh_lower_1281370 = _1281813;
goto l1281368;
l1281367: ;
union variant_220130 _1265919_6139;
_1265919_6139.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6141;
_1265920_6141.e0 = 1;
_1265920_6141.e1 = _1265919_6139;
pbh_lower_1281370 = _1265920_6141;
goto l1281368;
l1281368: ;
bh_lower_1281370 = pbh_lower_1281370;
unsigned int _1281371;
_1281371 = bh_lower_1281370.e0;
bool _1281372;
_1281372 = _1281371 == 0;
int _1281374;
_1281374 = _1008741_1281297.e2;
if (_1281372) goto l1281373; else goto l1281810;
l1281810: ;
pmap_boundary_mode_1281384 = bh_lower_1281370;
goto l1281382;
l1281373: ;
union variant_220130 _1281375;
_1281375 = bh_lower_1281370.e1;
int idx_1281376;
idx_1281376 = _1281375.qs32;
bool _1281377;
_1281377 = _1281374 <= idx_1281376;
if (_1281377) goto l1281378; else goto l1281807;
l1281807: ;
union variant_220130 _1281808;
_1281808.qs32 = idx_1281376;
struct_BoundaryMode_220129 _1281809;
_1281809.e0 = 0;
_1281809.e1 = _1281808;
pmap_boundary_mode_1281381 = _1281809;
goto l1281379;
l1281378: ;
union variant_220130 _1265919_6152;
_1265919_6152.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6154;
_1265920_6154.e0 = 1;
_1265920_6154.e1 = _1265919_6152;
pmap_boundary_mode_1281381 = _1265920_6154;
goto l1281379;
l1281379: ;
map_boundary_mode_1281381 = pmap_boundary_mode_1281381;
pmap_boundary_mode_1281384 = map_boundary_mode_1281381;
goto l1281382;
l1281382: ;
map_boundary_mode_1281384 = pmap_boundary_mode_1281384;
int _1281393;
_1281393 = _1008741_1281297.e3;
union variant_220130 _1281391;
_1281391 = map_boundary_mode_1281384.e1;
unsigned int _1281387;
_1281387 = map_boundary_mode_1281384.e0;
unsigned int _1281385;
_1281385 = map_boundary_mode_1281362.e0;
union variant_220130 _1281395;
_1281395 = map_boundary_mode_1281362.e1;
bool _1281388;
_1281388 = _1281387 == 0;
bool _1281386;
_1281386 = _1281385 == 0;
bool _1281389;
_1281389 = _1281386 & _1281388;
if (_1281389) goto l1281390; else goto l1281798;
l1281798: ;
bool _1281799;
_1281799 = _1281385 == 1;
if (_1281799) goto l1281800; else goto l1281802;
l1281802: ;
bool _1281803;
_1281803 = _1281387 == 1;
if (_1281803) goto l1281804; else goto l1281806;
l1281806: ;
// bottom: float r4_1265918_6167;
// bottom: p_1281404 = r4_1265918_6167;
goto l1281402;
l1281804: ;
float c_1281805;
c_1281805 = _1281391.pf32;
p_1281404 = c_1281805;
goto l1281402;
l1281800: ;
float c_1281801;
c_1281801 = _1281395.pf32;
p_1281404 = c_1281801;
goto l1281402;
l1281390: ;
int x_1281396;
x_1281396 = _1281395.qs32;
int y_1281392;
y_1281392 = _1281391.qs32;
int _1281394;
_1281394 = y_1281392 * _1281393;
int _1281397;
_1281397 = _1281394 + x_1281396;
float* idx_1281398;
idx_1281398 = _1008740_1281296 + _1281397;
_1281401 = __ldg(idx_1281398);
p_1281401 = _1281401;
l1281399: ;
_1281401 = p_1281401;
p_1281404 = _1281401;
goto l1281402;
l1281402: ;
_1281404 = p_1281404;
int _1281405;
_1281405 = -1 + _1281343;
bool _1281406;
_1281406 = _1281405 < 0;
if (_1281406) goto l1281407; else goto l1281795;
l1281795: ;
union variant_220130 _1281796;
_1281796.qs32 = _1281405;
struct_BoundaryMode_220129 _1281797;
_1281797.e0 = 0;
_1281797.e1 = _1281796;
pbh_lower_1281410 = _1281797;
goto l1281408;
l1281407: ;
union variant_220130 _1265919_6173;
_1265919_6173.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6175;
_1265920_6175.e0 = 1;
_1265920_6175.e1 = _1265919_6173;
pbh_lower_1281410 = _1265920_6175;
goto l1281408;
l1281408: ;
bh_lower_1281410 = pbh_lower_1281410;
unsigned int _1281411;
_1281411 = bh_lower_1281410.e0;
bool _1281412;
_1281412 = _1281411 == 0;
if (_1281412) goto l1281413; else goto l1281794;
l1281794: ;
pmap_boundary_mode_1281423 = bh_lower_1281410;
goto l1281421;
l1281413: ;
union variant_220130 _1281414;
_1281414 = bh_lower_1281410.e1;
int idx_1281415;
idx_1281415 = _1281414.qs32;
bool _1281416;
_1281416 = _1281352 <= idx_1281415;
if (_1281416) goto l1281417; else goto l1281791;
l1281791: ;
union variant_220130 _1281792;
_1281792.qs32 = idx_1281415;
struct_BoundaryMode_220129 _1281793;
_1281793.e0 = 0;
_1281793.e1 = _1281792;
pmap_boundary_mode_1281420 = _1281793;
goto l1281418;
l1281417: ;
union variant_220130 _1265919_6185;
_1265919_6185.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6187;
_1265920_6187.e0 = 1;
_1265920_6187.e1 = _1265919_6185;
pmap_boundary_mode_1281420 = _1265920_6187;
goto l1281418;
l1281418: ;
map_boundary_mode_1281420 = pmap_boundary_mode_1281420;
pmap_boundary_mode_1281423 = map_boundary_mode_1281420;
goto l1281421;
l1281421: ;
map_boundary_mode_1281423 = pmap_boundary_mode_1281423;
bool _1281424;
_1281424 = _1281364 < 0;
union variant_220130 _1281749;
_1281749.qs32 = _1281364;
struct_BoundaryMode_220129 _1281750;
_1281750.e0 = 0;
_1281750.e1 = _1281749;
if (_1281424) goto l1281425; else goto l1281790;
l1281790: ;
pbh_lower_1281428 = _1281750;
goto l1281426;
l1281425: ;
union variant_220130 _1265919_6195;
_1265919_6195.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6197;
_1265920_6197.e0 = 1;
_1265920_6197.e1 = _1265919_6195;
pbh_lower_1281428 = _1265920_6197;
goto l1281426;
l1281426: ;
bh_lower_1281428 = pbh_lower_1281428;
unsigned int _1281429;
_1281429 = bh_lower_1281428.e0;
bool _1281430;
_1281430 = _1281429 == 0;
if (_1281430) goto l1281431; else goto l1281789;
l1281789: ;
pmap_boundary_mode_1281441 = bh_lower_1281428;
goto l1281439;
l1281431: ;
union variant_220130 _1281432;
_1281432 = bh_lower_1281428.e1;
int idx_1281433;
idx_1281433 = _1281432.qs32;
bool _1281434;
_1281434 = _1281374 <= idx_1281433;
if (_1281434) goto l1281435; else goto l1281786;
l1281786: ;
union variant_220130 _1281787;
_1281787.qs32 = idx_1281433;
struct_BoundaryMode_220129 _1281788;
_1281788.e0 = 0;
_1281788.e1 = _1281787;
pmap_boundary_mode_1281438 = _1281788;
goto l1281436;
l1281435: ;
union variant_220130 _1265919_6207;
_1265919_6207.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6209;
_1265920_6209.e0 = 1;
_1265920_6209.e1 = _1265919_6207;
pmap_boundary_mode_1281438 = _1265920_6209;
goto l1281436;
l1281436: ;
map_boundary_mode_1281438 = pmap_boundary_mode_1281438;
pmap_boundary_mode_1281441 = map_boundary_mode_1281438;
goto l1281439;
l1281439: ;
map_boundary_mode_1281441 = pmap_boundary_mode_1281441;
union variant_220130 _1281448;
_1281448 = map_boundary_mode_1281441.e1;
union variant_220130 _1281451;
_1281451 = map_boundary_mode_1281423.e1;
unsigned int _1281444;
_1281444 = map_boundary_mode_1281441.e0;
unsigned int _1281442;
_1281442 = map_boundary_mode_1281423.e0;
bool _1281445;
_1281445 = _1281444 == 0;
bool _1281443;
_1281443 = _1281442 == 0;
bool _1281446;
_1281446 = _1281443 & _1281445;
if (_1281446) goto l1281447; else goto l1281777;
l1281777: ;
bool _1281778;
_1281778 = _1281442 == 1;
if (_1281778) goto l1281779; else goto l1281781;
l1281781: ;
bool _1281782;
_1281782 = _1281444 == 1;
if (_1281782) goto l1281783; else goto l1281785;
l1281785: ;
// bottom: float r4_1265918_6221;
// bottom: p_1281460 = r4_1265918_6221;
goto l1281458;
l1281783: ;
float c_1281784;
c_1281784 = _1281448.pf32;
p_1281460 = c_1281784;
goto l1281458;
l1281779: ;
float c_1281780;
c_1281780 = _1281451.pf32;
p_1281460 = c_1281780;
goto l1281458;
l1281447: ;
int y_1281449;
y_1281449 = _1281448.qs32;
int x_1281452;
x_1281452 = _1281451.qs32;
int _1281450;
_1281450 = y_1281449 * _1281393;
int _1281453;
_1281453 = _1281450 + x_1281452;
float* idx_1281454;
idx_1281454 = _1008740_1281296 + _1281453;
_1281457 = __ldg(idx_1281454);
p_1281457 = _1281457;
l1281455: ;
_1281457 = p_1281457;
p_1281460 = _1281457;
goto l1281458;
l1281458: ;
_1281460 = p_1281460;
if (_1281344) goto l1281461; else goto l1281776;
l1281776: ;
pbh_lower_1281464 = _1281734;
goto l1281462;
l1281461: ;
union variant_220130 _1265919_6222;
_1265919_6222.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6224;
_1265920_6224.e0 = 1;
_1265920_6224.e1 = _1265919_6222;
pbh_lower_1281464 = _1265920_6224;
goto l1281462;
l1281462: ;
bh_lower_1281464 = pbh_lower_1281464;
unsigned int _1281465;
_1281465 = bh_lower_1281464.e0;
bool _1281466;
_1281466 = _1281465 == 0;
if (_1281466) goto l1281467; else goto l1281775;
l1281775: ;
pmap_boundary_mode_1281477 = bh_lower_1281464;
goto l1281475;
l1281467: ;
union variant_220130 _1281468;
_1281468 = bh_lower_1281464.e1;
int idx_1281469;
idx_1281469 = _1281468.qs32;
bool _1281470;
_1281470 = _1281352 <= idx_1281469;
if (_1281470) goto l1281471; else goto l1281772;
l1281772: ;
union variant_220130 _1281773;
_1281773.qs32 = idx_1281469;
struct_BoundaryMode_220129 _1281774;
_1281774.e0 = 0;
_1281774.e1 = _1281773;
pmap_boundary_mode_1281474 = _1281774;
goto l1281472;
l1281471: ;
union variant_220130 _1265919_6234;
_1265919_6234.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6236;
_1265920_6236.e0 = 1;
_1265920_6236.e1 = _1265919_6234;
pmap_boundary_mode_1281474 = _1265920_6236;
goto l1281472;
l1281472: ;
map_boundary_mode_1281474 = pmap_boundary_mode_1281474;
pmap_boundary_mode_1281477 = map_boundary_mode_1281474;
goto l1281475;
l1281475: ;
map_boundary_mode_1281477 = pmap_boundary_mode_1281477;
if (_1281424) goto l1281478; else goto l1281771;
l1281771: ;
pbh_lower_1281481 = _1281750;
goto l1281479;
l1281478: ;
union variant_220130 _1265919_6240;
_1265919_6240.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6242;
_1265920_6242.e0 = 1;
_1265920_6242.e1 = _1265919_6240;
pbh_lower_1281481 = _1265920_6242;
goto l1281479;
l1281479: ;
bh_lower_1281481 = pbh_lower_1281481;
unsigned int _1281482;
_1281482 = bh_lower_1281481.e0;
bool _1281483;
_1281483 = _1281482 == 0;
if (_1281483) goto l1281484; else goto l1281770;
l1281770: ;
pmap_boundary_mode_1281494 = bh_lower_1281481;
goto l1281492;
l1281484: ;
union variant_220130 _1281485;
_1281485 = bh_lower_1281481.e1;
int idx_1281486;
idx_1281486 = _1281485.qs32;
bool _1281487;
_1281487 = _1281374 <= idx_1281486;
if (_1281487) goto l1281488; else goto l1281767;
l1281767: ;
union variant_220130 _1281768;
_1281768.qs32 = idx_1281486;
struct_BoundaryMode_220129 _1281769;
_1281769.e0 = 0;
_1281769.e1 = _1281768;
pmap_boundary_mode_1281491 = _1281769;
goto l1281489;
l1281488: ;
union variant_220130 _1265919_6252;
_1265919_6252.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6254;
_1265920_6254.e0 = 1;
_1265920_6254.e1 = _1265919_6252;
pmap_boundary_mode_1281491 = _1265920_6254;
goto l1281489;
l1281489: ;
map_boundary_mode_1281491 = pmap_boundary_mode_1281491;
pmap_boundary_mode_1281494 = map_boundary_mode_1281491;
goto l1281492;
l1281492: ;
map_boundary_mode_1281494 = pmap_boundary_mode_1281494;
union variant_220130 _1281504;
_1281504 = map_boundary_mode_1281477.e1;
unsigned int _1281497;
_1281497 = map_boundary_mode_1281494.e0;
unsigned int _1281495;
_1281495 = map_boundary_mode_1281477.e0;
bool _1281498;
_1281498 = _1281497 == 0;
union variant_220130 _1281501;
_1281501 = map_boundary_mode_1281494.e1;
bool _1281496;
_1281496 = _1281495 == 0;
bool _1281499;
_1281499 = _1281496 & _1281498;
if (_1281499) goto l1281500; else goto l1281758;
l1281758: ;
bool _1281759;
_1281759 = _1281495 == 1;
if (_1281759) goto l1281760; else goto l1281762;
l1281762: ;
bool _1281763;
_1281763 = _1281497 == 1;
if (_1281763) goto l1281764; else goto l1281766;
l1281766: ;
// bottom: float r4_1265918_6266;
// bottom: p_1281513 = r4_1265918_6266;
goto l1281511;
l1281764: ;
float c_1281765;
c_1281765 = _1281501.pf32;
p_1281513 = c_1281765;
goto l1281511;
l1281760: ;
float c_1281761;
c_1281761 = _1281504.pf32;
p_1281513 = c_1281761;
goto l1281511;
l1281500: ;
int y_1281502;
y_1281502 = _1281501.qs32;
int x_1281505;
x_1281505 = _1281504.qs32;
int _1281503;
_1281503 = y_1281502 * _1281393;
int _1281506;
_1281506 = _1281503 + x_1281505;
float* idx_1281507;
idx_1281507 = _1008740_1281296 + _1281506;
_1281510 = __ldg(idx_1281507);
p_1281510 = _1281510;
l1281508: ;
_1281510 = p_1281510;
p_1281513 = _1281510;
goto l1281511;
l1281511: ;
_1281513 = p_1281513;
int _1281514;
_1281514 = 1 + _1281343;
bool _1281515;
_1281515 = _1281514 < 0;
if (_1281515) goto l1281516; else goto l1281755;
l1281755: ;
union variant_220130 _1281756;
_1281756.qs32 = _1281514;
struct_BoundaryMode_220129 _1281757;
_1281757.e0 = 0;
_1281757.e1 = _1281756;
pbh_lower_1281519 = _1281757;
goto l1281517;
l1281516: ;
union variant_220130 _1265919_6272;
_1265919_6272.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6274;
_1265920_6274.e0 = 1;
_1265920_6274.e1 = _1265919_6272;
pbh_lower_1281519 = _1265920_6274;
goto l1281517;
l1281517: ;
bh_lower_1281519 = pbh_lower_1281519;
unsigned int _1281520;
_1281520 = bh_lower_1281519.e0;
bool _1281521;
_1281521 = _1281520 == 0;
if (_1281521) goto l1281522; else goto l1281754;
l1281754: ;
pmap_boundary_mode_1281532 = bh_lower_1281519;
goto l1281530;
l1281522: ;
union variant_220130 _1281523;
_1281523 = bh_lower_1281519.e1;
int idx_1281524;
idx_1281524 = _1281523.qs32;
bool _1281525;
_1281525 = _1281352 <= idx_1281524;
if (_1281525) goto l1281526; else goto l1281751;
l1281751: ;
union variant_220130 _1281752;
_1281752.qs32 = idx_1281524;
struct_BoundaryMode_220129 _1281753;
_1281753.e0 = 0;
_1281753.e1 = _1281752;
pmap_boundary_mode_1281529 = _1281753;
goto l1281527;
l1281526: ;
union variant_220130 _1265919_6284;
_1265919_6284.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6286;
_1265920_6286.e0 = 1;
_1265920_6286.e1 = _1265919_6284;
pmap_boundary_mode_1281529 = _1265920_6286;
goto l1281527;
l1281527: ;
map_boundary_mode_1281529 = pmap_boundary_mode_1281529;
pmap_boundary_mode_1281532 = map_boundary_mode_1281529;
goto l1281530;
l1281530: ;
map_boundary_mode_1281532 = pmap_boundary_mode_1281532;
if (_1281424) goto l1281533; else goto l1281748;
l1281748: ;
pbh_lower_1281536 = _1281750;
goto l1281534;
l1281533: ;
union variant_220130 _1265919_6290;
_1265919_6290.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6292;
_1265920_6292.e0 = 1;
_1265920_6292.e1 = _1265919_6290;
pbh_lower_1281536 = _1265920_6292;
goto l1281534;
l1281534: ;
bh_lower_1281536 = pbh_lower_1281536;
unsigned int _1281537;
_1281537 = bh_lower_1281536.e0;
bool _1281538;
_1281538 = _1281537 == 0;
if (_1281538) goto l1281539; else goto l1281747;
l1281747: ;
pmap_boundary_mode_1281549 = bh_lower_1281536;
goto l1281547;
l1281539: ;
union variant_220130 _1281540;
_1281540 = bh_lower_1281536.e1;
int idx_1281541;
idx_1281541 = _1281540.qs32;
bool _1281542;
_1281542 = _1281374 <= idx_1281541;
if (_1281542) goto l1281543; else goto l1281744;
l1281744: ;
union variant_220130 _1281745;
_1281745.qs32 = idx_1281541;
struct_BoundaryMode_220129 _1281746;
_1281746.e0 = 0;
_1281746.e1 = _1281745;
pmap_boundary_mode_1281546 = _1281746;
goto l1281544;
l1281543: ;
union variant_220130 _1265919_6302;
_1265919_6302.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6304;
_1265920_6304.e0 = 1;
_1265920_6304.e1 = _1265919_6302;
pmap_boundary_mode_1281546 = _1265920_6304;
goto l1281544;
l1281544: ;
map_boundary_mode_1281546 = pmap_boundary_mode_1281546;
pmap_boundary_mode_1281549 = map_boundary_mode_1281546;
goto l1281547;
l1281547: ;
map_boundary_mode_1281549 = pmap_boundary_mode_1281549;
unsigned int _1281550;
_1281550 = map_boundary_mode_1281532.e0;
unsigned int _1281552;
_1281552 = map_boundary_mode_1281549.e0;
bool _1281553;
_1281553 = _1281552 == 0;
union variant_220130 _1281556;
_1281556 = map_boundary_mode_1281549.e1;
bool _1281551;
_1281551 = _1281550 == 0;
union variant_220130 _1281559;
_1281559 = map_boundary_mode_1281532.e1;
bool _1281554;
_1281554 = _1281551 & _1281553;
if (_1281554) goto l1281555; else goto l1281735;
l1281735: ;
bool _1281736;
_1281736 = _1281550 == 1;
if (_1281736) goto l1281737; else goto l1281739;
l1281739: ;
bool _1281740;
_1281740 = _1281552 == 1;
if (_1281740) goto l1281741; else goto l1281743;
l1281743: ;
// bottom: float r4_1265918_6316;
// bottom: p_1281568 = r4_1265918_6316;
goto l1281566;
l1281741: ;
float c_1281742;
c_1281742 = _1281556.pf32;
p_1281568 = c_1281742;
goto l1281566;
l1281737: ;
float c_1281738;
c_1281738 = _1281559.pf32;
p_1281568 = c_1281738;
goto l1281566;
l1281555: ;
int x_1281560;
x_1281560 = _1281559.qs32;
int y_1281557;
y_1281557 = _1281556.qs32;
int _1281558;
_1281558 = y_1281557 * _1281393;
int _1281561;
_1281561 = _1281558 + x_1281560;
float* idx_1281562;
idx_1281562 = _1008740_1281296 + _1281561;
_1281565 = __ldg(idx_1281562);
p_1281565 = _1281565;
l1281563: ;
_1281565 = p_1281565;
p_1281568 = _1281565;
goto l1281566;
l1281566: ;
_1281568 = p_1281568;
if (_1281344) goto l1281569; else goto l1281732;
l1281732: ;
pbh_lower_1281572 = _1281734;
goto l1281570;
l1281569: ;
union variant_220130 _1265919_6317;
_1265919_6317.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6319;
_1265920_6319.e0 = 1;
_1265920_6319.e1 = _1265919_6317;
pbh_lower_1281572 = _1265920_6319;
goto l1281570;
l1281570: ;
bh_lower_1281572 = pbh_lower_1281572;
unsigned int _1281573;
_1281573 = bh_lower_1281572.e0;
bool _1281574;
_1281574 = _1281573 == 0;
if (_1281574) goto l1281575; else goto l1281731;
l1281731: ;
pmap_boundary_mode_1281585 = bh_lower_1281572;
goto l1281583;
l1281575: ;
union variant_220130 _1281576;
_1281576 = bh_lower_1281572.e1;
int idx_1281577;
idx_1281577 = _1281576.qs32;
bool _1281578;
_1281578 = _1281352 <= idx_1281577;
if (_1281578) goto l1281579; else goto l1281728;
l1281728: ;
union variant_220130 _1281729;
_1281729.qs32 = idx_1281577;
struct_BoundaryMode_220129 _1281730;
_1281730.e0 = 0;
_1281730.e1 = _1281729;
pmap_boundary_mode_1281582 = _1281730;
goto l1281580;
l1281579: ;
union variant_220130 _1265919_6329;
_1265919_6329.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6331;
_1265920_6331.e0 = 1;
_1265920_6331.e1 = _1265919_6329;
pmap_boundary_mode_1281582 = _1265920_6331;
goto l1281580;
l1281580: ;
map_boundary_mode_1281582 = pmap_boundary_mode_1281582;
pmap_boundary_mode_1281585 = map_boundary_mode_1281582;
goto l1281583;
l1281583: ;
map_boundary_mode_1281585 = pmap_boundary_mode_1281585;
int _1281586;
_1281586 = 1 + _1281364;
bool _1281587;
_1281587 = _1281586 < 0;
if (_1281587) goto l1281588; else goto l1281725;
l1281725: ;
union variant_220130 _1281726;
_1281726.qs32 = _1281586;
struct_BoundaryMode_220129 _1281727;
_1281727.e0 = 0;
_1281727.e1 = _1281726;
pbh_lower_1281591 = _1281727;
goto l1281589;
l1281588: ;
union variant_220130 _1265919_6340;
_1265919_6340.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6342;
_1265920_6342.e0 = 1;
_1265920_6342.e1 = _1265919_6340;
pbh_lower_1281591 = _1265920_6342;
goto l1281589;
l1281589: ;
bh_lower_1281591 = pbh_lower_1281591;
unsigned int _1281592;
_1281592 = bh_lower_1281591.e0;
bool _1281593;
_1281593 = _1281592 == 0;
if (_1281593) goto l1281594; else goto l1281724;
l1281724: ;
pmap_boundary_mode_1281604 = bh_lower_1281591;
goto l1281602;
l1281594: ;
union variant_220130 _1281595;
_1281595 = bh_lower_1281591.e1;
int idx_1281596;
idx_1281596 = _1281595.qs32;
bool _1281597;
_1281597 = _1281374 <= idx_1281596;
if (_1281597) goto l1281598; else goto l1281721;
l1281721: ;
union variant_220130 _1281722;
_1281722.qs32 = idx_1281596;
struct_BoundaryMode_220129 _1281723;
_1281723.e0 = 0;
_1281723.e1 = _1281722;
pmap_boundary_mode_1281601 = _1281723;
goto l1281599;
l1281598: ;
union variant_220130 _1265919_6352;
_1265919_6352.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6354;
_1265920_6354.e0 = 1;
_1265920_6354.e1 = _1265919_6352;
pmap_boundary_mode_1281601 = _1265920_6354;
goto l1281599;
l1281599: ;
map_boundary_mode_1281601 = pmap_boundary_mode_1281601;
pmap_boundary_mode_1281604 = map_boundary_mode_1281601;
goto l1281602;
l1281602: ;
map_boundary_mode_1281604 = pmap_boundary_mode_1281604;
union variant_220130 _1281614;
_1281614 = map_boundary_mode_1281585.e1;
unsigned int _1281605;
_1281605 = map_boundary_mode_1281585.e0;
unsigned int _1281607;
_1281607 = map_boundary_mode_1281604.e0;
bool _1281606;
_1281606 = _1281605 == 0;
union variant_220130 _1281611;
_1281611 = map_boundary_mode_1281604.e1;
bool _1281608;
_1281608 = _1281607 == 0;
bool _1281609;
_1281609 = _1281606 & _1281608;
if (_1281609) goto l1281610; else goto l1281712;
l1281712: ;
bool _1281713;
_1281713 = _1281605 == 1;
if (_1281713) goto l1281714; else goto l1281716;
l1281716: ;
bool _1281717;
_1281717 = _1281607 == 1;
if (_1281717) goto l1281718; else goto l1281720;
l1281720: ;
// bottom: float r4_1265918_6366;
// bottom: p_1281623 = r4_1265918_6366;
goto l1281621;
l1281718: ;
float c_1281719;
c_1281719 = _1281611.pf32;
p_1281623 = c_1281719;
goto l1281621;
l1281714: ;
float c_1281715;
c_1281715 = _1281614.pf32;
p_1281623 = c_1281715;
goto l1281621;
l1281610: ;
int y_1281612;
y_1281612 = _1281611.qs32;
int x_1281615;
x_1281615 = _1281614.qs32;
int _1281613;
_1281613 = y_1281612 * _1281393;
int _1281616;
_1281616 = _1281613 + x_1281615;
float* idx_1281617;
idx_1281617 = _1008740_1281296 + _1281616;
_1281620 = __ldg(idx_1281617);
p_1281620 = _1281620;
l1281618: ;
_1281620 = p_1281620;
p_1281623 = _1281620;
goto l1281621;
l1281621: ;
_1281623 = p_1281623;
float _1281636;
_1281636 = _1281635;
float _1281641;
_1281641 = -4.000000e+00f * _1281513;
float _1281639;
_1281639 = 1.000000e+00f * _1281460;
float _1281643;
_1281643 = 1.000000e+00f * _1281568;
float _1281637;
_1281637 = 1.000000e+00f * _1281404;
float _1281645;
_1281645 = 1.000000e+00f * _1281623;
float _1281638;
_1281638 = 0.000000e+00f + _1281637;
int _1281624;
_1281624 = 64 * tid_y_1281305;
float _1281640;
_1281640 = _1281638 + _1281639;
int _1281625;
_1281625 = _1281624 + tid_x_1281302;
float _1281642;
_1281642 = _1281640 + _1281641;
float* idx_1281626;
idx_1281626 = spm_1281317 + _1281625;
float _1281644;
_1281644 = _1281642 + _1281643;
float _1281646;
_1281646 = _1281644 + _1281645;
float val_1281647;
val_1281647 = _1281636 + _1281646;
*idx_1281626 = val_1281647;
__syncthreads();
l1281649: ;
bool _1281651;
_1281651 = tid_x_1281302 < 32;
if (_1281651) goto l1281652; else goto l1281711;
l1281711: ;
goto l1281710;
l1281652: ;
int _1281653;
_1281653 = blockDim_y_1281311 * blockIdx_y_1281314;
int _1281654;
_1281654 = threadIdx_y_1281308 + _1281653;
int _1281655;
_1281655 = _1281654 % 2;
bool _1281656;
_1281656 = _1281655 == 0;
if (_1281656) goto l1281657; else goto l1281709;
l1281709: ;
goto l1281710;
l1281710: ;
return ;
l1281657: ;
_1281660 = blockDim_x();
p_1281660 = _1281660;
l1281658: ;
_1281660 = p_1281660;
_1281663 = blockIdx_x();
p_1281663 = _1281663;
l1281661: ;
_1281663 = p_1281663;
_1281666 = blockDim_y();
p_1281666 = _1281666;
l1281664: ;
_1281666 = p_1281666;
_1281669 = blockIdx_y();
p_1281669 = _1281669;
l1281667: ;
_1281669 = p_1281669;
int _1281697;
_1281697 = _1281660 * _1281663;
int _1281670;
_1281670 = 128 * tid_y_1281305;
int _1281671;
_1281671 = 2 * tid_x_1281302;
int _1281691;
_1281691 = _1281666 * _1281669;
int _1281680;
_1281680 = 2 * tid_y_1281305;
int _1281694;
_1281694 = _1008739_1281295.e3;
int _1281672;
_1281672 = _1281670 + _1281671;
int _1281698;
_1281698 = _1281697 / 2;
int _1281692;
_1281692 = _1281691 / 2;
int _1281681;
_1281681 = 1 + _1281680;
float* idx_1281673;
idx_1281673 = spm_1281317 + _1281672;
int _1281676;
_1281676 = 1 + _1281672;
int _1281693;
_1281693 = tid_y_1281305 + _1281692;
int _1281682;
_1281682 = 64 * _1281681;
float _1281674;
_1281674 = *idx_1281673;
float* idx_1281677;
idx_1281677 = spm_1281317 + _1281676;
int _1281695;
_1281695 = _1281693 * _1281694;
int _1281683;
_1281683 = _1281682 + _1281671;
float _1281701;
_1281701 = _1281674;
float _1281678;
_1281678 = *idx_1281677;
int _1281696;
_1281696 = _1281695 + tid_x_1281302;
int _1281687;
_1281687 = 1 + _1281683;
float* idx_1281684;
idx_1281684 = spm_1281317 + _1281683;
float _1281702;
_1281702 = _1281678;
int _1281699;
_1281699 = _1281696 + _1281698;
float* idx_1281688;
idx_1281688 = spm_1281317 + _1281687;
float _1281685;
_1281685 = *idx_1281684;
float _1281703;
_1281703 = _1281701 + _1281702;
float* idx_1281700;
idx_1281700 = _1008742_1281298 + _1281699;
float _1281704;
_1281704 = _1281685;
float _1281705;
_1281705 = _1281703 + _1281704;
float _1281689;
_1281689 = *idx_1281688;
float _1281706;
_1281706 = _1281689;
float val_1281707;
val_1281707 = _1281705 + _1281706;
*idx_1281700 = val_1281707;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1017443(struct_Img_220118 _1017446_1282098, float* _1017447_1282099, struct_Img_220118 _1017448_1282100, float* _1017449_1282101, struct_Img_220118 _1017450_1282102, float* _1017451_1282103) {
int _1282106;
int p_1282106;
int _1282109;
int p_1282109;
int _1282112;
int p_1282112;
int _1282115;
int p_1282115;
int _1282118;
int p_1282118;
int _1282121;
int p_1282121;
int _1282124;
int p_1282124;
struct_BoundaryMode_220129 bh_upper_1282135;
struct_BoundaryMode_220129 pbh_upper_1282135;
float _1282150;
float p_1282150;
float _1282153;
float p_1282153;
struct_BoundaryMode_220129 bh_upper_1282157;
struct_BoundaryMode_220129 pbh_upper_1282157;
float _1282168;
float p_1282168;
float _1282171;
float p_1282171;
struct_BoundaryMode_220129 bh_upper_1282177;
struct_BoundaryMode_220129 pbh_upper_1282177;
float _1282187;
float p_1282187;
float _1282190;
float p_1282190;
struct_BoundaryMode_220129 bh_upper_1282196;
struct_BoundaryMode_220129 pbh_upper_1282196;
float _1282206;
float p_1282206;
float _1282209;
float p_1282209;
struct_BoundaryMode_220129 bh_upper_1282213;
struct_BoundaryMode_220129 pbh_upper_1282213;
float _1282225;
float p_1282225;
float _1282228;
float p_1282228;
_1282106 = threadIdx_x();
p_1282106 = _1282106;
l1282104: ;
_1282106 = p_1282106;
_1282109 = blockDim_x();
p_1282109 = _1282109;
l1282107: ;
_1282109 = p_1282109;
_1282112 = blockIdx_x();
p_1282112 = _1282112;
l1282110: ;
_1282112 = p_1282112;
_1282115 = threadIdx_y();
p_1282115 = _1282115;
l1282113: ;
_1282115 = p_1282115;
_1282118 = blockDim_y();
p_1282118 = _1282118;
l1282116: ;
_1282118 = p_1282118;
_1282121 = blockIdx_y();
p_1282121 = _1282121;
l1282119: ;
_1282121 = p_1282121;
_1282124 = blockDim_y();
p_1282124 = _1282124;
l1282122: ;
_1282124 = p_1282124;
int _1282126;
_1282126 = _1017448_1282100.e1;
int _1282129;
_1282129 = _1282109 * _1282112;
int _1282127;
_1282127 = _1282126 - 128;
int _1282125;
_1282125 = _1017450_1282102.e1;
int _1282128;
_1282128 = _1282127 + _1282106;
int gid_x_1282130;
gid_x_1282130 = _1282128 + _1282129;
union variant_220130 _1282258;
_1282258.qs32 = gid_x_1282130;
bool _1282131;
_1282131 = _1282125 <= gid_x_1282130;
struct_BoundaryMode_220129 _1282259;
_1282259.e0 = 0;
_1282259.e1 = _1282258;
if (_1282131) goto l1282132; else goto l1282288;
l1282288: ;
pbh_upper_1282135 = _1282259;
goto l1282133;
l1282132: ;
union variant_220130 _1265919_6393;
_1265919_6393.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6395;
_1265920_6395.e0 = 1;
_1265920_6395.e1 = _1265919_6393;
pbh_upper_1282135 = _1265920_6395;
goto l1282133;
l1282133: ;
bh_upper_1282135 = pbh_upper_1282135;
unsigned int _1282136;
_1282136 = bh_upper_1282135.e0;
int _1282139;
_1282139 = _1282118 * _1282121;
union variant_220130 _1282144;
_1282144 = bh_upper_1282135.e1;
int _1282142;
_1282142 = _1017450_1282102.e3;
bool _1282137;
_1282137 = _1282136 == 0;
int gid_y_1282140;
gid_y_1282140 = _1282115 + _1282139;
int _1282141;
_1282141 = 1 + gid_y_1282140;
int _1282143;
_1282143 = _1282141 * _1282142;
if (_1282137) goto l1282138; else goto l1282283;
l1282283: ;
bool _1282284;
_1282284 = _1282136 == 1;
if (_1282284) goto l1282285; else goto l1282287;
l1282287: ;
// bottom: float r4_1265918_6405;
// bottom: p_1282153 = r4_1265918_6405;
goto l1282151;
l1282285: ;
float c_1282286;
c_1282286 = _1282144.pf32;
p_1282153 = c_1282286;
goto l1282151;
l1282138: ;
int x_1282145;
x_1282145 = _1282144.qs32;
int _1282146;
_1282146 = _1282143 + x_1282145;
float* idx_1282147;
idx_1282147 = _1017449_1282101 + _1282146;
_1282150 = __ldg(idx_1282147);
p_1282150 = _1282150;
l1282148: ;
_1282150 = p_1282150;
p_1282153 = _1282150;
goto l1282151;
l1282151: ;
_1282153 = p_1282153;
int _1282234;
_1282234 = _1017446_1282098.e3;
int _1282235;
_1282235 = _1282141 * _1282234;
int _1282236;
_1282236 = _1282235 + gid_x_1282130;
float* idx_1282237;
idx_1282237 = _1017451_1282103 + _1282236;
float _1282238;
_1282238 = *idx_1282237;
if (_1282131) goto l1282154; else goto l1282282;
l1282282: ;
pbh_upper_1282157 = _1282259;
goto l1282155;
l1282154: ;
union variant_220130 _1265919_6407;
_1265919_6407.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6409;
_1265920_6409.e0 = 1;
_1265920_6409.e1 = _1265919_6407;
pbh_upper_1282157 = _1265920_6409;
goto l1282155;
l1282155: ;
bh_upper_1282157 = pbh_upper_1282157;
union variant_220130 _1282162;
_1282162 = bh_upper_1282157.e1;
unsigned int _1282158;
_1282158 = bh_upper_1282157.e0;
bool _1282159;
_1282159 = _1282158 == 0;
if (_1282159) goto l1282160; else goto l1282276;
l1282276: ;
bool _1282277;
_1282277 = _1282158 == 1;
if (_1282277) goto l1282278; else goto l1282280;
l1282280: ;
// bottom: float r4_1265918_6417;
// bottom: p_1282171 = r4_1265918_6417;
goto l1282169;
l1282278: ;
float c_1282279;
c_1282279 = _1282162.pf32;
p_1282171 = c_1282279;
goto l1282169;
l1282160: ;
int _1282161;
_1282161 = gid_y_1282140 * _1282142;
int x_1282163;
x_1282163 = _1282162.qs32;
int _1282164;
_1282164 = _1282161 + x_1282163;
float* idx_1282165;
idx_1282165 = _1017449_1282101 + _1282164;
_1282168 = __ldg(idx_1282165);
p_1282168 = _1282168;
l1282166: ;
_1282168 = p_1282168;
p_1282171 = _1282168;
goto l1282169;
l1282169: ;
_1282171 = p_1282171;
int _1282172;
_1282172 = -1 + gid_x_1282130;
bool _1282173;
_1282173 = _1282125 <= _1282172;
if (_1282173) goto l1282174; else goto l1282273;
l1282273: ;
union variant_220130 _1282274;
_1282274.qs32 = _1282172;
struct_BoundaryMode_220129 _1282275;
_1282275.e0 = 0;
_1282275.e1 = _1282274;
pbh_upper_1282177 = _1282275;
goto l1282175;
l1282174: ;
union variant_220130 _1265919_6422;
_1265919_6422.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6424;
_1265920_6424.e0 = 1;
_1265920_6424.e1 = _1265919_6422;
pbh_upper_1282177 = _1265920_6424;
goto l1282175;
l1282175: ;
bh_upper_1282177 = pbh_upper_1282177;
unsigned int _1282178;
_1282178 = bh_upper_1282177.e0;
bool _1282179;
_1282179 = _1282178 == 0;
union variant_220130 _1282181;
_1282181 = bh_upper_1282177.e1;
if (_1282179) goto l1282180; else goto l1282268;
l1282268: ;
bool _1282269;
_1282269 = _1282178 == 1;
if (_1282269) goto l1282270; else goto l1282272;
l1282272: ;
// bottom: float r4_1265918_6432;
// bottom: p_1282190 = r4_1265918_6432;
goto l1282188;
l1282270: ;
float c_1282271;
c_1282271 = _1282181.pf32;
p_1282190 = c_1282271;
goto l1282188;
l1282180: ;
int x_1282182;
x_1282182 = _1282181.qs32;
int _1282183;
_1282183 = _1282143 + x_1282182;
float* idx_1282184;
idx_1282184 = _1017449_1282101 + _1282183;
_1282187 = __ldg(idx_1282184);
p_1282187 = _1282187;
l1282185: ;
_1282187 = p_1282187;
p_1282190 = _1282187;
goto l1282188;
l1282188: ;
_1282190 = p_1282190;
int _1282191;
_1282191 = 1 + gid_x_1282130;
bool _1282192;
_1282192 = _1282125 <= _1282191;
if (_1282192) goto l1282193; else goto l1282265;
l1282265: ;
union variant_220130 _1282266;
_1282266.qs32 = _1282191;
struct_BoundaryMode_220129 _1282267;
_1282267.e0 = 0;
_1282267.e1 = _1282266;
pbh_upper_1282196 = _1282267;
goto l1282194;
l1282193: ;
union variant_220130 _1265919_6437;
_1265919_6437.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6439;
_1265920_6439.e0 = 1;
_1265920_6439.e1 = _1265919_6437;
pbh_upper_1282196 = _1265920_6439;
goto l1282194;
l1282194: ;
bh_upper_1282196 = pbh_upper_1282196;
union variant_220130 _1282200;
_1282200 = bh_upper_1282196.e1;
unsigned int _1282197;
_1282197 = bh_upper_1282196.e0;
bool _1282198;
_1282198 = _1282197 == 0;
if (_1282198) goto l1282199; else goto l1282260;
l1282260: ;
bool _1282261;
_1282261 = _1282197 == 1;
if (_1282261) goto l1282262; else goto l1282264;
l1282264: ;
// bottom: float r4_1265918_6447;
// bottom: p_1282209 = r4_1265918_6447;
goto l1282207;
l1282262: ;
float c_1282263;
c_1282263 = _1282200.pf32;
p_1282209 = c_1282263;
goto l1282207;
l1282199: ;
int x_1282201;
x_1282201 = _1282200.qs32;
int _1282202;
_1282202 = _1282143 + x_1282201;
float* idx_1282203;
idx_1282203 = _1017449_1282101 + _1282202;
_1282206 = __ldg(idx_1282203);
p_1282206 = _1282206;
l1282204: ;
_1282206 = p_1282206;
p_1282209 = _1282206;
goto l1282207;
l1282207: ;
_1282209 = p_1282209;
if (_1282131) goto l1282210; else goto l1282257;
l1282257: ;
pbh_upper_1282213 = _1282259;
goto l1282211;
l1282210: ;
union variant_220130 _1265919_6448;
_1265919_6448.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6450;
_1265920_6450.e0 = 1;
_1265920_6450.e1 = _1265919_6448;
pbh_upper_1282213 = _1265920_6450;
goto l1282211;
l1282211: ;
bh_upper_1282213 = pbh_upper_1282213;
union variant_220130 _1282219;
_1282219 = bh_upper_1282213.e1;
unsigned int _1282214;
_1282214 = bh_upper_1282213.e0;
bool _1282215;
_1282215 = _1282214 == 0;
if (_1282215) goto l1282216; else goto l1282252;
l1282252: ;
bool _1282253;
_1282253 = _1282214 == 1;
if (_1282253) goto l1282254; else goto l1282256;
l1282256: ;
// bottom: float r4_1265918_6458;
// bottom: p_1282228 = r4_1265918_6458;
goto l1282226;
l1282254: ;
float c_1282255;
c_1282255 = _1282219.pf32;
p_1282228 = c_1282255;
goto l1282226;
l1282216: ;
int x_1282220;
x_1282220 = _1282219.qs32;
int _1282217;
_1282217 = 2 + gid_y_1282140;
int _1282218;
_1282218 = _1282217 * _1282142;
int _1282221;
_1282221 = _1282218 + x_1282220;
float* idx_1282222;
idx_1282222 = _1017449_1282101 + _1282221;
_1282225 = __ldg(idx_1282222);
p_1282225 = _1282225;
l1282223: ;
_1282225 = p_1282225;
p_1282228 = _1282225;
goto l1282226;
l1282226: ;
_1282228 = p_1282228;
int _1282229;
_1282229 = _1017448_1282100.e3;
float _1282239;
_1282239 = _1282238;
float _1282240;
_1282240 = 2.000000e-01f * _1282239;
float _1282233;
_1282233 = 2.000000e-01f * _1282153;
float _1282246;
_1282246 = 2.500000e-01f * _1282209;
float _1282248;
_1282248 = 2.500000e-01f * _1282228;
float _1282244;
_1282244 = 2.500000e-01f * _1282190;
int _1282230;
_1282230 = _1282141 * _1282229;
float _1282242;
_1282242 = 2.500000e-01f * _1282171;
float _1282243;
_1282243 = 0.000000e+00f + _1282242;
float _1282241;
_1282241 = _1282233 + _1282240;
float _1282245;
_1282245 = _1282243 + _1282244;
int _1282231;
_1282231 = _1282230 + gid_x_1282130;
float _1282247;
_1282247 = _1282245 + _1282246;
float* idx_1282232;
idx_1282232 = _1017447_1282099 + _1282231;
float _1282249;
_1282249 = _1282247 + _1282248;
float val_1282250;
val_1282250 = _1282241 + _1282249;
*idx_1282232 = val_1282250;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1036437(float* _1036440_1285003, struct_Img_220118 _1036441_1285004, float* _1036442_1285005, struct_Img_220118 _1036443_1285006, struct_Img_220118 _1036444_1285007, float* _1036445_1285008) {
int _1285011;
int p_1285011;
int _1285014;
int p_1285014;
int _1285017;
int p_1285017;
int _1285020;
int p_1285020;
int _1285023;
int p_1285023;
int _1285026;
int p_1285026;
int _1285029;
int p_1285029;
struct_BoundaryMode_220129 bh_upper_1285040;
struct_BoundaryMode_220129 pbh_upper_1285040;
float _1285055;
float p_1285055;
float _1285058;
float p_1285058;
struct_BoundaryMode_220129 bh_upper_1285062;
struct_BoundaryMode_220129 pbh_upper_1285062;
float _1285073;
float p_1285073;
float _1285076;
float p_1285076;
struct_BoundaryMode_220129 bh_upper_1285082;
struct_BoundaryMode_220129 pbh_upper_1285082;
float _1285092;
float p_1285092;
float _1285095;
float p_1285095;
struct_BoundaryMode_220129 bh_upper_1285101;
struct_BoundaryMode_220129 pbh_upper_1285101;
float _1285111;
float p_1285111;
float _1285114;
float p_1285114;
struct_BoundaryMode_220129 bh_upper_1285118;
struct_BoundaryMode_220129 pbh_upper_1285118;
float _1285130;
float p_1285130;
float _1285133;
float p_1285133;
_1285011 = threadIdx_x();
p_1285011 = _1285011;
l1285009: ;
_1285011 = p_1285011;
_1285014 = blockDim_x();
p_1285014 = _1285014;
l1285012: ;
_1285014 = p_1285014;
_1285017 = blockIdx_x();
p_1285017 = _1285017;
l1285015: ;
_1285017 = p_1285017;
_1285020 = threadIdx_y();
p_1285020 = _1285020;
l1285018: ;
_1285020 = p_1285020;
_1285023 = blockDim_y();
p_1285023 = _1285023;
l1285021: ;
_1285023 = p_1285023;
_1285026 = blockIdx_y();
p_1285026 = _1285026;
l1285024: ;
_1285026 = p_1285026;
_1285029 = blockDim_y();
p_1285029 = _1285029;
l1285027: ;
_1285029 = p_1285029;
int _1285031;
_1285031 = _1036444_1285007.e1;
int _1285034;
_1285034 = _1285014 * _1285017;
int _1285030;
_1285030 = _1036443_1285006.e1;
int _1285032;
_1285032 = _1285031 - 128;
int _1285033;
_1285033 = _1285032 + _1285011;
int gid_x_1285035;
gid_x_1285035 = _1285033 + _1285034;
union variant_220130 _1285163;
_1285163.qs32 = gid_x_1285035;
bool _1285036;
_1285036 = _1285030 <= gid_x_1285035;
struct_BoundaryMode_220129 _1285164;
_1285164.e0 = 0;
_1285164.e1 = _1285163;
if (_1285036) goto l1285037; else goto l1285193;
l1285193: ;
pbh_upper_1285040 = _1285164;
goto l1285038;
l1285037: ;
union variant_220130 _1265919_6474;
_1265919_6474.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6476;
_1265920_6476.e0 = 1;
_1265920_6476.e1 = _1265919_6474;
pbh_upper_1285040 = _1265920_6476;
goto l1285038;
l1285038: ;
bh_upper_1285040 = pbh_upper_1285040;
unsigned int _1285041;
_1285041 = bh_upper_1285040.e0;
int _1285044;
_1285044 = _1285023 * _1285026;
int _1285047;
_1285047 = _1036443_1285006.e3;
int gid_y_1285045;
gid_y_1285045 = _1285020 + _1285044;
union variant_220130 _1285049;
_1285049 = bh_upper_1285040.e1;
bool _1285042;
_1285042 = _1285041 == 0;
int _1285046;
_1285046 = 1 + gid_y_1285045;
int _1285048;
_1285048 = _1285046 * _1285047;
if (_1285042) goto l1285043; else goto l1285188;
l1285188: ;
bool _1285189;
_1285189 = _1285041 == 1;
if (_1285189) goto l1285190; else goto l1285192;
l1285192: ;
// bottom: float r4_1265918_6486;
// bottom: p_1285058 = r4_1265918_6486;
goto l1285056;
l1285190: ;
float c_1285191;
c_1285191 = _1285049.pf32;
p_1285058 = c_1285191;
goto l1285056;
l1285043: ;
int x_1285050;
x_1285050 = _1285049.qs32;
int _1285051;
_1285051 = _1285048 + x_1285050;
float* idx_1285052;
idx_1285052 = _1036442_1285005 + _1285051;
_1285055 = __ldg(idx_1285052);
p_1285055 = _1285055;
l1285053: ;
_1285055 = p_1285055;
p_1285058 = _1285055;
goto l1285056;
l1285056: ;
_1285058 = p_1285058;
int _1285139;
_1285139 = _1036441_1285004.e3;
int _1285140;
_1285140 = _1285046 * _1285139;
int _1285141;
_1285141 = _1285140 + gid_x_1285035;
float* idx_1285142;
idx_1285142 = _1036445_1285008 + _1285141;
float _1285143;
_1285143 = *idx_1285142;
if (_1285036) goto l1285059; else goto l1285187;
l1285187: ;
pbh_upper_1285062 = _1285164;
goto l1285060;
l1285059: ;
union variant_220130 _1265919_6488;
_1265919_6488.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6490;
_1265920_6490.e0 = 1;
_1265920_6490.e1 = _1265919_6488;
pbh_upper_1285062 = _1265920_6490;
goto l1285060;
l1285060: ;
bh_upper_1285062 = pbh_upper_1285062;
union variant_220130 _1285067;
_1285067 = bh_upper_1285062.e1;
unsigned int _1285063;
_1285063 = bh_upper_1285062.e0;
bool _1285064;
_1285064 = _1285063 == 0;
if (_1285064) goto l1285065; else goto l1285181;
l1285181: ;
bool _1285182;
_1285182 = _1285063 == 1;
if (_1285182) goto l1285183; else goto l1285185;
l1285185: ;
// bottom: float r4_1265918_6498;
// bottom: p_1285076 = r4_1265918_6498;
goto l1285074;
l1285183: ;
float c_1285184;
c_1285184 = _1285067.pf32;
p_1285076 = c_1285184;
goto l1285074;
l1285065: ;
int _1285066;
_1285066 = gid_y_1285045 * _1285047;
int x_1285068;
x_1285068 = _1285067.qs32;
int _1285069;
_1285069 = _1285066 + x_1285068;
float* idx_1285070;
idx_1285070 = _1036442_1285005 + _1285069;
_1285073 = __ldg(idx_1285070);
p_1285073 = _1285073;
l1285071: ;
_1285073 = p_1285073;
p_1285076 = _1285073;
goto l1285074;
l1285074: ;
_1285076 = p_1285076;
int _1285077;
_1285077 = -1 + gid_x_1285035;
bool _1285078;
_1285078 = _1285030 <= _1285077;
if (_1285078) goto l1285079; else goto l1285178;
l1285178: ;
union variant_220130 _1285179;
_1285179.qs32 = _1285077;
struct_BoundaryMode_220129 _1285180;
_1285180.e0 = 0;
_1285180.e1 = _1285179;
pbh_upper_1285082 = _1285180;
goto l1285080;
l1285079: ;
union variant_220130 _1265919_6503;
_1265919_6503.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6505;
_1265920_6505.e0 = 1;
_1265920_6505.e1 = _1265919_6503;
pbh_upper_1285082 = _1265920_6505;
goto l1285080;
l1285080: ;
bh_upper_1285082 = pbh_upper_1285082;
union variant_220130 _1285086;
_1285086 = bh_upper_1285082.e1;
unsigned int _1285083;
_1285083 = bh_upper_1285082.e0;
bool _1285084;
_1285084 = _1285083 == 0;
if (_1285084) goto l1285085; else goto l1285173;
l1285173: ;
bool _1285174;
_1285174 = _1285083 == 1;
if (_1285174) goto l1285175; else goto l1285177;
l1285177: ;
// bottom: float r4_1265918_6513;
// bottom: p_1285095 = r4_1265918_6513;
goto l1285093;
l1285175: ;
float c_1285176;
c_1285176 = _1285086.pf32;
p_1285095 = c_1285176;
goto l1285093;
l1285085: ;
int x_1285087;
x_1285087 = _1285086.qs32;
int _1285088;
_1285088 = _1285048 + x_1285087;
float* idx_1285089;
idx_1285089 = _1036442_1285005 + _1285088;
_1285092 = __ldg(idx_1285089);
p_1285092 = _1285092;
l1285090: ;
_1285092 = p_1285092;
p_1285095 = _1285092;
goto l1285093;
l1285093: ;
_1285095 = p_1285095;
int _1285096;
_1285096 = 1 + gid_x_1285035;
bool _1285097;
_1285097 = _1285030 <= _1285096;
if (_1285097) goto l1285098; else goto l1285170;
l1285170: ;
union variant_220130 _1285171;
_1285171.qs32 = _1285096;
struct_BoundaryMode_220129 _1285172;
_1285172.e0 = 0;
_1285172.e1 = _1285171;
pbh_upper_1285101 = _1285172;
goto l1285099;
l1285098: ;
union variant_220130 _1265919_6518;
_1265919_6518.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6520;
_1265920_6520.e0 = 1;
_1265920_6520.e1 = _1265919_6518;
pbh_upper_1285101 = _1265920_6520;
goto l1285099;
l1285099: ;
bh_upper_1285101 = pbh_upper_1285101;
unsigned int _1285102;
_1285102 = bh_upper_1285101.e0;
bool _1285103;
_1285103 = _1285102 == 0;
union variant_220130 _1285105;
_1285105 = bh_upper_1285101.e1;
if (_1285103) goto l1285104; else goto l1285165;
l1285165: ;
bool _1285166;
_1285166 = _1285102 == 1;
if (_1285166) goto l1285167; else goto l1285169;
l1285169: ;
// bottom: float r4_1265918_6528;
// bottom: p_1285114 = r4_1265918_6528;
goto l1285112;
l1285167: ;
float c_1285168;
c_1285168 = _1285105.pf32;
p_1285114 = c_1285168;
goto l1285112;
l1285104: ;
int x_1285106;
x_1285106 = _1285105.qs32;
int _1285107;
_1285107 = _1285048 + x_1285106;
float* idx_1285108;
idx_1285108 = _1036442_1285005 + _1285107;
_1285111 = __ldg(idx_1285108);
p_1285111 = _1285111;
l1285109: ;
_1285111 = p_1285111;
p_1285114 = _1285111;
goto l1285112;
l1285112: ;
_1285114 = p_1285114;
if (_1285036) goto l1285115; else goto l1285162;
l1285162: ;
pbh_upper_1285118 = _1285164;
goto l1285116;
l1285115: ;
union variant_220130 _1265919_6529;
_1265919_6529.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6531;
_1265920_6531.e0 = 1;
_1265920_6531.e1 = _1265919_6529;
pbh_upper_1285118 = _1265920_6531;
goto l1285116;
l1285116: ;
bh_upper_1285118 = pbh_upper_1285118;
unsigned int _1285119;
_1285119 = bh_upper_1285118.e0;
bool _1285120;
_1285120 = _1285119 == 0;
union variant_220130 _1285124;
_1285124 = bh_upper_1285118.e1;
if (_1285120) goto l1285121; else goto l1285157;
l1285157: ;
bool _1285158;
_1285158 = _1285119 == 1;
if (_1285158) goto l1285159; else goto l1285161;
l1285161: ;
// bottom: float r4_1265918_6539;
// bottom: p_1285133 = r4_1265918_6539;
goto l1285131;
l1285159: ;
float c_1285160;
c_1285160 = _1285124.pf32;
p_1285133 = c_1285160;
goto l1285131;
l1285121: ;
int x_1285125;
x_1285125 = _1285124.qs32;
int _1285122;
_1285122 = 2 + gid_y_1285045;
int _1285123;
_1285123 = _1285122 * _1285047;
int _1285126;
_1285126 = _1285123 + x_1285125;
float* idx_1285127;
idx_1285127 = _1036442_1285005 + _1285126;
_1285130 = __ldg(idx_1285127);
p_1285130 = _1285130;
l1285128: ;
_1285130 = p_1285130;
p_1285133 = _1285130;
goto l1285131;
l1285131: ;
_1285133 = p_1285133;
float _1285138;
_1285138 = 2.000000e-01f * _1285058;
float _1285151;
_1285151 = 2.500000e-01f * _1285114;
float _1285147;
_1285147 = 2.500000e-01f * _1285076;
float _1285149;
_1285149 = 2.500000e-01f * _1285095;
int _1285134;
_1285134 = _1036444_1285007.e3;
float _1285153;
_1285153 = 2.500000e-01f * _1285133;
float _1285144;
_1285144 = _1285143;
float _1285148;
_1285148 = 0.000000e+00f + _1285147;
float _1285150;
_1285150 = _1285148 + _1285149;
int _1285135;
_1285135 = _1285046 * _1285134;
float _1285145;
_1285145 = 2.000000e-01f * _1285144;
float _1285152;
_1285152 = _1285150 + _1285151;
int _1285136;
_1285136 = _1285135 + gid_x_1285035;
float _1285146;
_1285146 = _1285138 + _1285145;
float _1285154;
_1285154 = _1285152 + _1285153;
float* idx_1285137;
idx_1285137 = _1036440_1285003 + _1285136;
float val_1285155;
val_1285155 = _1285146 + _1285154;
*idx_1285137 = val_1285155;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1021752(float* _1021755_1280671, struct_Img_220118 _1021756_1280672, float* _1021757_1280673, float* _1021758_1280674, struct_Img_220118 _1021759_1280675, struct_Img_220118 _1021760_1280676) {
int _1280679;
int p_1280679;
int _1280682;
int p_1280682;
int _1280685;
int p_1280685;
int _1280688;
int p_1280688;
int _1280691;
int p_1280691;
int _1280694;
int p_1280694;
int _1280697;
int p_1280697;
struct_BoundaryMode_220129 bh_upper_1280708;
struct_BoundaryMode_220129 pbh_upper_1280708;
float _1280723;
float p_1280723;
float _1280726;
float p_1280726;
struct_BoundaryMode_220129 bh_upper_1280732;
struct_BoundaryMode_220129 pbh_upper_1280732;
float _1280744;
float p_1280744;
float _1280747;
float p_1280747;
struct_BoundaryMode_220129 bh_upper_1280751;
struct_BoundaryMode_220129 pbh_upper_1280751;
float _1280763;
float p_1280763;
float _1280766;
float p_1280766;
struct_BoundaryMode_220129 bh_upper_1280770;
struct_BoundaryMode_220129 pbh_upper_1280770;
float _1280782;
float p_1280782;
float _1280785;
float p_1280785;
struct_BoundaryMode_220129 bh_upper_1280791;
struct_BoundaryMode_220129 pbh_upper_1280791;
float _1280803;
float p_1280803;
float _1280806;
float p_1280806;
_1280679 = threadIdx_x();
p_1280679 = _1280679;
l1280677: ;
_1280679 = p_1280679;
_1280682 = blockDim_x();
p_1280682 = _1280682;
l1280680: ;
_1280682 = p_1280682;
_1280685 = blockIdx_x();
p_1280685 = _1280685;
l1280683: ;
_1280685 = p_1280685;
_1280688 = threadIdx_y();
p_1280688 = _1280688;
l1280686: ;
_1280688 = p_1280688;
_1280691 = blockDim_y();
p_1280691 = _1280691;
l1280689: ;
_1280691 = p_1280691;
_1280694 = blockIdx_y();
p_1280694 = _1280694;
l1280692: ;
_1280694 = p_1280694;
_1280697 = blockDim_y();
p_1280697 = _1280697;
l1280695: ;
_1280697 = p_1280697;
int _1280699;
_1280699 = _1021756_1280672.e2;
int _1280698;
_1280698 = _1021759_1280675.e2;
int _1280700;
_1280700 = _1280699 - 1;
int _1280702;
_1280702 = _1280691 * _1280694;
int _1280701;
_1280701 = _1280700 + _1280688;
int gid_y_1280703;
gid_y_1280703 = _1280701 + _1280702;
bool _1280704;
_1280704 = _1280698 <= gid_y_1280703;
union variant_220130 _1280846;
_1280846.qs32 = gid_y_1280703;
struct_BoundaryMode_220129 _1280847;
_1280847.e0 = 0;
_1280847.e1 = _1280846;
if (_1280704) goto l1280705; else goto l1280868;
l1280868: ;
pbh_upper_1280708 = _1280847;
goto l1280706;
l1280705: ;
union variant_220130 _1265919_6555;
_1265919_6555.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6557;
_1265920_6557.e0 = 1;
_1265920_6557.e1 = _1265919_6555;
pbh_upper_1280708 = _1265920_6557;
goto l1280706;
l1280706: ;
bh_upper_1280708 = pbh_upper_1280708;
union variant_220130 _1280712;
_1280712 = bh_upper_1280708.e1;
int _1280716;
_1280716 = _1280682 * _1280685;
int _1280714;
_1280714 = _1021759_1280675.e3;
int gid_x_1280717;
gid_x_1280717 = _1280679 + _1280716;
unsigned int _1280709;
_1280709 = bh_upper_1280708.e0;
bool _1280710;
_1280710 = _1280709 == 0;
if (_1280710) goto l1280711; else goto l1280863;
l1280863: ;
bool _1280864;
_1280864 = _1280709 == 1;
if (_1280864) goto l1280865; else goto l1280867;
l1280867: ;
// bottom: float r4_1265918_6566;
// bottom: p_1280726 = r4_1265918_6566;
goto l1280724;
l1280865: ;
float c_1280866;
c_1280866 = _1280712.pf32;
p_1280726 = c_1280866;
goto l1280724;
l1280711: ;
int y_1280713;
y_1280713 = _1280712.qs32;
int _1280715;
_1280715 = y_1280713 * _1280714;
int _1280718;
_1280718 = _1280715 + gid_x_1280717;
int _1280719;
_1280719 = 128 + _1280718;
float* idx_1280720;
idx_1280720 = _1021758_1280674 + _1280719;
_1280723 = __ldg(idx_1280720);
p_1280723 = _1280723;
l1280721: ;
_1280723 = p_1280723;
p_1280726 = _1280723;
goto l1280724;
l1280724: ;
_1280726 = p_1280726;
int _1280727;
_1280727 = -1 + gid_y_1280703;
bool _1280728;
_1280728 = _1280698 <= _1280727;
int _1280813;
_1280813 = _1021760_1280676.e3;
int _1280814;
_1280814 = gid_y_1280703 * _1280813;
int _1280815;
_1280815 = _1280814 + gid_x_1280717;
int _1280816;
_1280816 = 128 + _1280815;
float* idx_1280817;
idx_1280817 = _1021755_1280671 + _1280816;
float _1280818;
_1280818 = *idx_1280817;
if (_1280728) goto l1280729; else goto l1280860;
l1280860: ;
union variant_220130 _1280861;
_1280861.qs32 = _1280727;
struct_BoundaryMode_220129 _1280862;
_1280862.e0 = 0;
_1280862.e1 = _1280861;
pbh_upper_1280732 = _1280862;
goto l1280730;
l1280729: ;
union variant_220130 _1265919_6574;
_1265919_6574.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6576;
_1265920_6576.e0 = 1;
_1265920_6576.e1 = _1265919_6574;
pbh_upper_1280732 = _1265920_6576;
goto l1280730;
l1280730: ;
bh_upper_1280732 = pbh_upper_1280732;
union variant_220130 _1280736;
_1280736 = bh_upper_1280732.e1;
unsigned int _1280733;
_1280733 = bh_upper_1280732.e0;
bool _1280734;
_1280734 = _1280733 == 0;
if (_1280734) goto l1280735; else goto l1280854;
l1280854: ;
bool _1280855;
_1280855 = _1280733 == 1;
if (_1280855) goto l1280856; else goto l1280858;
l1280858: ;
// bottom: float r4_1265918_6584;
// bottom: p_1280747 = r4_1265918_6584;
goto l1280745;
l1280856: ;
float c_1280857;
c_1280857 = _1280736.pf32;
p_1280747 = c_1280857;
goto l1280745;
l1280735: ;
int y_1280737;
y_1280737 = _1280736.qs32;
int _1280738;
_1280738 = y_1280737 * _1280714;
int _1280739;
_1280739 = _1280738 + gid_x_1280717;
int _1280740;
_1280740 = 128 + _1280739;
float* idx_1280741;
idx_1280741 = _1021758_1280674 + _1280740;
_1280744 = __ldg(idx_1280741);
p_1280744 = _1280744;
l1280742: ;
_1280744 = p_1280744;
p_1280747 = _1280744;
goto l1280745;
l1280745: ;
_1280747 = p_1280747;
if (_1280704) goto l1280748; else goto l1280853;
l1280853: ;
pbh_upper_1280751 = _1280847;
goto l1280749;
l1280748: ;
union variant_220130 _1265919_6586;
_1265919_6586.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6588;
_1265920_6588.e0 = 1;
_1265920_6588.e1 = _1265919_6586;
pbh_upper_1280751 = _1265920_6588;
goto l1280749;
l1280749: ;
bh_upper_1280751 = pbh_upper_1280751;
union variant_220130 _1280755;
_1280755 = bh_upper_1280751.e1;
unsigned int _1280752;
_1280752 = bh_upper_1280751.e0;
bool _1280753;
_1280753 = _1280752 == 0;
if (_1280753) goto l1280754; else goto l1280848;
l1280848: ;
bool _1280849;
_1280849 = _1280752 == 1;
if (_1280849) goto l1280850; else goto l1280852;
l1280852: ;
// bottom: float r4_1265918_6596;
// bottom: p_1280766 = r4_1265918_6596;
goto l1280764;
l1280850: ;
float c_1280851;
c_1280851 = _1280755.pf32;
p_1280766 = c_1280851;
goto l1280764;
l1280754: ;
int y_1280756;
y_1280756 = _1280755.qs32;
int _1280757;
_1280757 = y_1280756 * _1280714;
int _1280758;
_1280758 = _1280757 + gid_x_1280717;
int _1280759;
_1280759 = 127 + _1280758;
float* idx_1280760;
idx_1280760 = _1021758_1280674 + _1280759;
_1280763 = __ldg(idx_1280760);
p_1280763 = _1280763;
l1280761: ;
_1280763 = p_1280763;
p_1280766 = _1280763;
goto l1280764;
l1280764: ;
_1280766 = p_1280766;
if (_1280704) goto l1280767; else goto l1280845;
l1280845: ;
pbh_upper_1280770 = _1280847;
goto l1280768;
l1280767: ;
union variant_220130 _1265919_6598;
_1265919_6598.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6600;
_1265920_6600.e0 = 1;
_1265920_6600.e1 = _1265919_6598;
pbh_upper_1280770 = _1265920_6600;
goto l1280768;
l1280768: ;
bh_upper_1280770 = pbh_upper_1280770;
union variant_220130 _1280774;
_1280774 = bh_upper_1280770.e1;
unsigned int _1280771;
_1280771 = bh_upper_1280770.e0;
bool _1280772;
_1280772 = _1280771 == 0;
if (_1280772) goto l1280773; else goto l1280840;
l1280840: ;
bool _1280841;
_1280841 = _1280771 == 1;
if (_1280841) goto l1280842; else goto l1280844;
l1280844: ;
// bottom: float r4_1265918_6608;
// bottom: p_1280785 = r4_1265918_6608;
goto l1280783;
l1280842: ;
float c_1280843;
c_1280843 = _1280774.pf32;
p_1280785 = c_1280843;
goto l1280783;
l1280773: ;
int y_1280775;
y_1280775 = _1280774.qs32;
int _1280776;
_1280776 = y_1280775 * _1280714;
int _1280777;
_1280777 = _1280776 + gid_x_1280717;
int _1280778;
_1280778 = 129 + _1280777;
float* idx_1280779;
idx_1280779 = _1021758_1280674 + _1280778;
_1280782 = __ldg(idx_1280779);
p_1280782 = _1280782;
l1280780: ;
_1280782 = p_1280782;
p_1280785 = _1280782;
goto l1280783;
l1280783: ;
_1280785 = p_1280785;
int _1280786;
_1280786 = 1 + gid_y_1280703;
bool _1280787;
_1280787 = _1280698 <= _1280786;
if (_1280787) goto l1280788; else goto l1280837;
l1280837: ;
union variant_220130 _1280838;
_1280838.qs32 = _1280786;
struct_BoundaryMode_220129 _1280839;
_1280839.e0 = 0;
_1280839.e1 = _1280838;
pbh_upper_1280791 = _1280839;
goto l1280789;
l1280788: ;
union variant_220130 _1265919_6614;
_1265919_6614.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6616;
_1265920_6616.e0 = 1;
_1265920_6616.e1 = _1265919_6614;
pbh_upper_1280791 = _1265920_6616;
goto l1280789;
l1280789: ;
bh_upper_1280791 = pbh_upper_1280791;
unsigned int _1280792;
_1280792 = bh_upper_1280791.e0;
union variant_220130 _1280795;
_1280795 = bh_upper_1280791.e1;
bool _1280793;
_1280793 = _1280792 == 0;
if (_1280793) goto l1280794; else goto l1280832;
l1280832: ;
bool _1280833;
_1280833 = _1280792 == 1;
if (_1280833) goto l1280834; else goto l1280836;
l1280836: ;
// bottom: float r4_1265918_6624;
// bottom: p_1280806 = r4_1265918_6624;
goto l1280804;
l1280834: ;
float c_1280835;
c_1280835 = _1280795.pf32;
p_1280806 = c_1280835;
goto l1280804;
l1280794: ;
int y_1280796;
y_1280796 = _1280795.qs32;
int _1280797;
_1280797 = y_1280796 * _1280714;
int _1280798;
_1280798 = _1280797 + gid_x_1280717;
int _1280799;
_1280799 = 128 + _1280798;
float* idx_1280800;
idx_1280800 = _1021758_1280674 + _1280799;
_1280803 = __ldg(idx_1280800);
p_1280803 = _1280803;
l1280801: ;
_1280803 = p_1280803;
p_1280806 = _1280803;
goto l1280804;
l1280804: ;
_1280806 = p_1280806;
float _1280828;
_1280828 = 2.500000e-01f * _1280806;
float _1280812;
_1280812 = 2.000000e-01f * _1280726;
float _1280822;
_1280822 = 2.500000e-01f * _1280747;
float _1280819;
_1280819 = _1280818;
float _1280824;
_1280824 = 2.500000e-01f * _1280766;
int _1280807;
_1280807 = _1021756_1280672.e3;
float _1280823;
_1280823 = 0.000000e+00f + _1280822;
float _1280826;
_1280826 = 2.500000e-01f * _1280785;
float _1280820;
_1280820 = 2.000000e-01f * _1280819;
float _1280825;
_1280825 = _1280823 + _1280824;
int _1280808;
_1280808 = gid_y_1280703 * _1280807;
float _1280827;
_1280827 = _1280825 + _1280826;
float _1280821;
_1280821 = _1280812 + _1280820;
int _1280809;
_1280809 = _1280808 + gid_x_1280717;
float _1280829;
_1280829 = _1280827 + _1280828;
float val_1280830;
val_1280830 = _1280821 + _1280829;
int _1280810;
_1280810 = 128 + _1280809;
float* idx_1280811;
idx_1280811 = _1021757_1280673 + _1280810;
*idx_1280811 = val_1280830;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1024360(struct_Img_220118 _1024363_1266527, float* _1024364_1266528, struct_Img_220118 _1024365_1266529, float* _1024366_1266530, float* _1024367_1266531, struct_Img_220118 _1024368_1266532) {
int _1266535;
int p_1266535;
int _1266538;
int p_1266538;
int _1266541;
int p_1266541;
int _1266544;
int p_1266544;
int _1266547;
int p_1266547;
int _1266550;
int p_1266550;
int _1266553;
int p_1266553;
struct_BoundaryMode_220129 bh_lower_1266560;
struct_BoundaryMode_220129 pbh_lower_1266560;
float _1266575;
float p_1266575;
float _1266578;
float p_1266578;
struct_BoundaryMode_220129 bh_lower_1266582;
struct_BoundaryMode_220129 pbh_lower_1266582;
float _1266593;
float p_1266593;
float _1266596;
float p_1266596;
struct_BoundaryMode_220129 bh_lower_1266602;
struct_BoundaryMode_220129 pbh_lower_1266602;
float _1266612;
float p_1266612;
float _1266615;
float p_1266615;
struct_BoundaryMode_220129 bh_lower_1266621;
struct_BoundaryMode_220129 pbh_lower_1266621;
float _1266631;
float p_1266631;
float _1266634;
float p_1266634;
struct_BoundaryMode_220129 bh_lower_1266638;
struct_BoundaryMode_220129 pbh_lower_1266638;
float _1266650;
float p_1266650;
float _1266653;
float p_1266653;
_1266535 = threadIdx_x();
p_1266535 = _1266535;
l1266533: ;
_1266535 = p_1266535;
_1266538 = blockDim_x();
p_1266538 = _1266538;
l1266536: ;
_1266538 = p_1266538;
_1266541 = blockIdx_x();
p_1266541 = _1266541;
l1266539: ;
_1266541 = p_1266541;
_1266544 = threadIdx_y();
p_1266544 = _1266544;
l1266542: ;
_1266544 = p_1266544;
_1266547 = blockDim_y();
p_1266547 = _1266547;
l1266545: ;
_1266547 = p_1266547;
_1266550 = blockIdx_y();
p_1266550 = _1266550;
l1266548: ;
_1266550 = p_1266550;
_1266553 = blockDim_y();
p_1266553 = _1266553;
l1266551: ;
_1266553 = p_1266553;
int _1266554;
_1266554 = _1266538 * _1266541;
int gid_x_1266555;
gid_x_1266555 = _1266535 + _1266554;
union variant_220130 _1266683;
_1266683.qs32 = gid_x_1266555;
bool _1266556;
_1266556 = gid_x_1266555 < 0;
struct_BoundaryMode_220129 _1266684;
_1266684.e0 = 0;
_1266684.e1 = _1266683;
if (_1266556) goto l1266557; else goto l1266713;
l1266713: ;
pbh_lower_1266560 = _1266684;
goto l1266558;
l1266557: ;
union variant_220130 _1265919_6639;
_1265919_6639.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6641;
_1265920_6641.e0 = 1;
_1265920_6641.e1 = _1265919_6639;
pbh_lower_1266560 = _1265920_6641;
goto l1266558;
l1266558: ;
bh_lower_1266560 = pbh_lower_1266560;
unsigned int _1266561;
_1266561 = bh_lower_1266560.e0;
int _1266564;
_1266564 = _1266547 * _1266550;
int _1266567;
_1266567 = _1024363_1266527.e3;
union variant_220130 _1266569;
_1266569 = bh_lower_1266560.e1;
int gid_y_1266565;
gid_y_1266565 = _1266544 + _1266564;
bool _1266562;
_1266562 = _1266561 == 0;
int _1266566;
_1266566 = 1 + gid_y_1266565;
int _1266568;
_1266568 = _1266566 * _1266567;
if (_1266562) goto l1266563; else goto l1266708;
l1266708: ;
bool _1266709;
_1266709 = _1266561 == 1;
if (_1266709) goto l1266710; else goto l1266712;
l1266712: ;
// bottom: float r4_1265918_6651;
// bottom: p_1266578 = r4_1265918_6651;
goto l1266576;
l1266710: ;
float c_1266711;
c_1266711 = _1266569.pf32;
p_1266578 = c_1266711;
goto l1266576;
l1266563: ;
int x_1266570;
x_1266570 = _1266569.qs32;
int _1266571;
_1266571 = _1266568 + x_1266570;
float* idx_1266572;
idx_1266572 = _1024366_1266530 + _1266571;
_1266575 = __ldg(idx_1266572);
p_1266575 = _1266575;
l1266573: ;
_1266575 = p_1266575;
p_1266578 = _1266575;
goto l1266576;
l1266576: ;
_1266578 = p_1266578;
int _1266659;
_1266659 = _1024368_1266532.e3;
int _1266660;
_1266660 = _1266566 * _1266659;
int _1266661;
_1266661 = _1266660 + gid_x_1266555;
float* idx_1266662;
idx_1266662 = _1024364_1266528 + _1266661;
float _1266663;
_1266663 = *idx_1266662;
if (_1266556) goto l1266579; else goto l1266707;
l1266707: ;
pbh_lower_1266582 = _1266684;
goto l1266580;
l1266579: ;
union variant_220130 _1265919_6653;
_1265919_6653.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6655;
_1265920_6655.e0 = 1;
_1265920_6655.e1 = _1265919_6653;
pbh_lower_1266582 = _1265920_6655;
goto l1266580;
l1266580: ;
bh_lower_1266582 = pbh_lower_1266582;
union variant_220130 _1266587;
_1266587 = bh_lower_1266582.e1;
unsigned int _1266583;
_1266583 = bh_lower_1266582.e0;
bool _1266584;
_1266584 = _1266583 == 0;
if (_1266584) goto l1266585; else goto l1266701;
l1266701: ;
bool _1266702;
_1266702 = _1266583 == 1;
if (_1266702) goto l1266703; else goto l1266705;
l1266705: ;
// bottom: float r4_1265918_6663;
// bottom: p_1266596 = r4_1265918_6663;
goto l1266594;
l1266703: ;
float c_1266704;
c_1266704 = _1266587.pf32;
p_1266596 = c_1266704;
goto l1266594;
l1266585: ;
int x_1266588;
x_1266588 = _1266587.qs32;
int _1266586;
_1266586 = gid_y_1266565 * _1266567;
int _1266589;
_1266589 = _1266586 + x_1266588;
float* idx_1266590;
idx_1266590 = _1024366_1266530 + _1266589;
_1266593 = __ldg(idx_1266590);
p_1266593 = _1266593;
l1266591: ;
_1266593 = p_1266593;
p_1266596 = _1266593;
goto l1266594;
l1266594: ;
_1266596 = p_1266596;
int _1266597;
_1266597 = -1 + gid_x_1266555;
bool _1266598;
_1266598 = _1266597 < 0;
if (_1266598) goto l1266599; else goto l1266698;
l1266698: ;
union variant_220130 _1266699;
_1266699.qs32 = _1266597;
struct_BoundaryMode_220129 _1266700;
_1266700.e0 = 0;
_1266700.e1 = _1266699;
pbh_lower_1266602 = _1266700;
goto l1266600;
l1266599: ;
union variant_220130 _1265919_6669;
_1265919_6669.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6671;
_1265920_6671.e0 = 1;
_1265920_6671.e1 = _1265919_6669;
pbh_lower_1266602 = _1265920_6671;
goto l1266600;
l1266600: ;
bh_lower_1266602 = pbh_lower_1266602;
union variant_220130 _1266606;
_1266606 = bh_lower_1266602.e1;
unsigned int _1266603;
_1266603 = bh_lower_1266602.e0;
bool _1266604;
_1266604 = _1266603 == 0;
if (_1266604) goto l1266605; else goto l1266693;
l1266693: ;
bool _1266694;
_1266694 = _1266603 == 1;
if (_1266694) goto l1266695; else goto l1266697;
l1266697: ;
// bottom: float r4_1265918_6679;
// bottom: p_1266615 = r4_1265918_6679;
goto l1266613;
l1266695: ;
float c_1266696;
c_1266696 = _1266606.pf32;
p_1266615 = c_1266696;
goto l1266613;
l1266605: ;
int x_1266607;
x_1266607 = _1266606.qs32;
int _1266608;
_1266608 = _1266568 + x_1266607;
float* idx_1266609;
idx_1266609 = _1024366_1266530 + _1266608;
_1266612 = __ldg(idx_1266609);
p_1266612 = _1266612;
l1266610: ;
_1266612 = p_1266612;
p_1266615 = _1266612;
goto l1266613;
l1266613: ;
_1266615 = p_1266615;
int _1266616;
_1266616 = 1 + gid_x_1266555;
bool _1266617;
_1266617 = _1266616 < 0;
if (_1266617) goto l1266618; else goto l1266690;
l1266690: ;
union variant_220130 _1266691;
_1266691.qs32 = _1266616;
struct_BoundaryMode_220129 _1266692;
_1266692.e0 = 0;
_1266692.e1 = _1266691;
pbh_lower_1266621 = _1266692;
goto l1266619;
l1266618: ;
union variant_220130 _1265919_6685;
_1265919_6685.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6687;
_1265920_6687.e0 = 1;
_1265920_6687.e1 = _1265919_6685;
pbh_lower_1266621 = _1265920_6687;
goto l1266619;
l1266619: ;
bh_lower_1266621 = pbh_lower_1266621;
union variant_220130 _1266625;
_1266625 = bh_lower_1266621.e1;
unsigned int _1266622;
_1266622 = bh_lower_1266621.e0;
bool _1266623;
_1266623 = _1266622 == 0;
if (_1266623) goto l1266624; else goto l1266685;
l1266685: ;
bool _1266686;
_1266686 = _1266622 == 1;
if (_1266686) goto l1266687; else goto l1266689;
l1266689: ;
// bottom: float r4_1265918_6695;
// bottom: p_1266634 = r4_1265918_6695;
goto l1266632;
l1266687: ;
float c_1266688;
c_1266688 = _1266625.pf32;
p_1266634 = c_1266688;
goto l1266632;
l1266624: ;
int x_1266626;
x_1266626 = _1266625.qs32;
int _1266627;
_1266627 = _1266568 + x_1266626;
float* idx_1266628;
idx_1266628 = _1024366_1266530 + _1266627;
_1266631 = __ldg(idx_1266628);
p_1266631 = _1266631;
l1266629: ;
_1266631 = p_1266631;
p_1266634 = _1266631;
goto l1266632;
l1266632: ;
_1266634 = p_1266634;
if (_1266556) goto l1266635; else goto l1266682;
l1266682: ;
pbh_lower_1266638 = _1266684;
goto l1266636;
l1266635: ;
union variant_220130 _1265919_6696;
_1265919_6696.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6698;
_1265920_6698.e0 = 1;
_1265920_6698.e1 = _1265919_6696;
pbh_lower_1266638 = _1265920_6698;
goto l1266636;
l1266636: ;
bh_lower_1266638 = pbh_lower_1266638;
union variant_220130 _1266644;
_1266644 = bh_lower_1266638.e1;
unsigned int _1266639;
_1266639 = bh_lower_1266638.e0;
bool _1266640;
_1266640 = _1266639 == 0;
if (_1266640) goto l1266641; else goto l1266677;
l1266677: ;
bool _1266678;
_1266678 = _1266639 == 1;
if (_1266678) goto l1266679; else goto l1266681;
l1266681: ;
// bottom: float r4_1265918_6706;
// bottom: p_1266653 = r4_1265918_6706;
goto l1266651;
l1266679: ;
float c_1266680;
c_1266680 = _1266644.pf32;
p_1266653 = c_1266680;
goto l1266651;
l1266641: ;
int x_1266645;
x_1266645 = _1266644.qs32;
int _1266642;
_1266642 = 2 + gid_y_1266565;
int _1266643;
_1266643 = _1266642 * _1266567;
int _1266646;
_1266646 = _1266643 + x_1266645;
float* idx_1266647;
idx_1266647 = _1024366_1266530 + _1266646;
_1266650 = __ldg(idx_1266647);
p_1266650 = _1266650;
l1266648: ;
_1266650 = p_1266650;
p_1266653 = _1266650;
goto l1266651;
l1266651: ;
_1266653 = p_1266653;
float _1266667;
_1266667 = 2.500000e-01f * _1266596;
float _1266658;
_1266658 = 2.000000e-01f * _1266578;
float _1266671;
_1266671 = 2.500000e-01f * _1266634;
int _1266654;
_1266654 = _1024365_1266529.e3;
float _1266664;
_1266664 = _1266663;
float _1266669;
_1266669 = 2.500000e-01f * _1266615;
float _1266673;
_1266673 = 2.500000e-01f * _1266653;
int _1266655;
_1266655 = _1266566 * _1266654;
float _1266668;
_1266668 = 0.000000e+00f + _1266667;
float _1266665;
_1266665 = 2.000000e-01f * _1266664;
float _1266666;
_1266666 = _1266658 + _1266665;
float _1266670;
_1266670 = _1266668 + _1266669;
int _1266656;
_1266656 = _1266655 + gid_x_1266555;
float _1266672;
_1266672 = _1266670 + _1266671;
float* idx_1266657;
idx_1266657 = _1024367_1266531 + _1266656;
float _1266674;
_1266674 = _1266672 + _1266673;
float val_1266675;
val_1266675 = _1266666 + _1266674;
*idx_1266657 = val_1266675;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1011163(struct_Img_220118 _1011166_1279541, struct_Img_220118 _1011167_1279542, float* _1011168_1279543, struct_Img_220118 _1011169_1279544, float* _1011170_1279545, float* _1011171_1279546) {
int _1279549;
int p_1279549;
int _1279552;
int p_1279552;
int _1279555;
int p_1279555;
int _1279558;
int p_1279558;
int _1279561;
int p_1279561;
int _1279564;
int p_1279564;
int _1279567;
int p_1279567;
struct_BoundaryMode_220129 bh_lower_1279574;
struct_BoundaryMode_220129 pbh_lower_1279574;
float _1279589;
float p_1279589;
float _1279592;
float p_1279592;
struct_BoundaryMode_220129 bh_lower_1279598;
struct_BoundaryMode_220129 pbh_lower_1279598;
float _1279610;
float p_1279610;
float _1279613;
float p_1279613;
struct_BoundaryMode_220129 bh_lower_1279617;
struct_BoundaryMode_220129 pbh_lower_1279617;
float _1279629;
float p_1279629;
float _1279632;
float p_1279632;
struct_BoundaryMode_220129 bh_lower_1279636;
struct_BoundaryMode_220129 pbh_lower_1279636;
float _1279648;
float p_1279648;
float _1279651;
float p_1279651;
struct_BoundaryMode_220129 bh_lower_1279657;
struct_BoundaryMode_220129 pbh_lower_1279657;
float _1279669;
float p_1279669;
float _1279672;
float p_1279672;
_1279549 = threadIdx_x();
p_1279549 = _1279549;
l1279547: ;
_1279549 = p_1279549;
_1279552 = blockDim_x();
p_1279552 = _1279552;
l1279550: ;
_1279552 = p_1279552;
_1279555 = blockIdx_x();
p_1279555 = _1279555;
l1279553: ;
_1279555 = p_1279555;
_1279558 = threadIdx_y();
p_1279558 = _1279558;
l1279556: ;
_1279558 = p_1279558;
_1279561 = blockDim_y();
p_1279561 = _1279561;
l1279559: ;
_1279561 = p_1279561;
_1279564 = blockIdx_y();
p_1279564 = _1279564;
l1279562: ;
_1279564 = p_1279564;
_1279567 = blockDim_y();
p_1279567 = _1279567;
l1279565: ;
_1279567 = p_1279567;
int _1279568;
_1279568 = _1279561 * _1279564;
int gid_y_1279569;
gid_y_1279569 = _1279558 + _1279568;
union variant_220130 _1279712;
_1279712.qs32 = gid_y_1279569;
bool _1279570;
_1279570 = gid_y_1279569 < 0;
struct_BoundaryMode_220129 _1279713;
_1279713.e0 = 0;
_1279713.e1 = _1279712;
if (_1279570) goto l1279571; else goto l1279734;
l1279734: ;
pbh_lower_1279574 = _1279713;
goto l1279572;
l1279571: ;
union variant_220130 _1265919_6720;
_1265919_6720.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6722;
_1265920_6722.e0 = 1;
_1265920_6722.e1 = _1265919_6720;
pbh_lower_1279574 = _1265920_6722;
goto l1279572;
l1279572: ;
bh_lower_1279574 = pbh_lower_1279574;
unsigned int _1279575;
_1279575 = bh_lower_1279574.e0;
union variant_220130 _1279578;
_1279578 = bh_lower_1279574.e1;
int _1279580;
_1279580 = _1011166_1279541.e3;
bool _1279576;
_1279576 = _1279575 == 0;
int _1279582;
_1279582 = _1279552 * _1279555;
int gid_x_1279583;
gid_x_1279583 = _1279549 + _1279582;
if (_1279576) goto l1279577; else goto l1279729;
l1279729: ;
bool _1279730;
_1279730 = _1279575 == 1;
if (_1279730) goto l1279731; else goto l1279733;
l1279733: ;
// bottom: float r4_1265918_6731;
// bottom: p_1279592 = r4_1265918_6731;
goto l1279590;
l1279731: ;
float c_1279732;
c_1279732 = _1279578.pf32;
p_1279592 = c_1279732;
goto l1279590;
l1279577: ;
int y_1279579;
y_1279579 = _1279578.qs32;
int _1279581;
_1279581 = y_1279579 * _1279580;
int _1279584;
_1279584 = _1279581 + gid_x_1279583;
int _1279585;
_1279585 = 128 + _1279584;
float* idx_1279586;
idx_1279586 = _1011170_1279545 + _1279585;
_1279589 = __ldg(idx_1279586);
p_1279589 = _1279589;
l1279587: ;
_1279589 = p_1279589;
p_1279592 = _1279589;
goto l1279590;
l1279590: ;
_1279592 = p_1279592;
int _1279593;
_1279593 = -1 + gid_y_1279569;
bool _1279594;
_1279594 = _1279593 < 0;
int _1279679;
_1279679 = _1011167_1279542.e3;
int _1279680;
_1279680 = gid_y_1279569 * _1279679;
int _1279681;
_1279681 = _1279680 + gid_x_1279583;
int _1279682;
_1279682 = 128 + _1279681;
float* idx_1279683;
idx_1279683 = _1011171_1279546 + _1279682;
float _1279684;
_1279684 = *idx_1279683;
if (_1279594) goto l1279595; else goto l1279726;
l1279726: ;
union variant_220130 _1279727;
_1279727.qs32 = _1279593;
struct_BoundaryMode_220129 _1279728;
_1279728.e0 = 0;
_1279728.e1 = _1279727;
pbh_lower_1279598 = _1279728;
goto l1279596;
l1279595: ;
union variant_220130 _1265919_6740;
_1265919_6740.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6742;
_1265920_6742.e0 = 1;
_1265920_6742.e1 = _1265919_6740;
pbh_lower_1279598 = _1265920_6742;
goto l1279596;
l1279596: ;
bh_lower_1279598 = pbh_lower_1279598;
union variant_220130 _1279602;
_1279602 = bh_lower_1279598.e1;
unsigned int _1279599;
_1279599 = bh_lower_1279598.e0;
bool _1279600;
_1279600 = _1279599 == 0;
if (_1279600) goto l1279601; else goto l1279720;
l1279720: ;
bool _1279721;
_1279721 = _1279599 == 1;
if (_1279721) goto l1279722; else goto l1279724;
l1279724: ;
// bottom: float r4_1265918_6750;
// bottom: p_1279613 = r4_1265918_6750;
goto l1279611;
l1279722: ;
float c_1279723;
c_1279723 = _1279602.pf32;
p_1279613 = c_1279723;
goto l1279611;
l1279601: ;
int y_1279603;
y_1279603 = _1279602.qs32;
int _1279604;
_1279604 = y_1279603 * _1279580;
int _1279605;
_1279605 = _1279604 + gid_x_1279583;
int _1279606;
_1279606 = 128 + _1279605;
float* idx_1279607;
idx_1279607 = _1011170_1279545 + _1279606;
_1279610 = __ldg(idx_1279607);
p_1279610 = _1279610;
l1279608: ;
_1279610 = p_1279610;
p_1279613 = _1279610;
goto l1279611;
l1279611: ;
_1279613 = p_1279613;
if (_1279570) goto l1279614; else goto l1279719;
l1279719: ;
pbh_lower_1279617 = _1279713;
goto l1279615;
l1279614: ;
union variant_220130 _1265919_6752;
_1265919_6752.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6754;
_1265920_6754.e0 = 1;
_1265920_6754.e1 = _1265919_6752;
pbh_lower_1279617 = _1265920_6754;
goto l1279615;
l1279615: ;
bh_lower_1279617 = pbh_lower_1279617;
unsigned int _1279618;
_1279618 = bh_lower_1279617.e0;
bool _1279619;
_1279619 = _1279618 == 0;
union variant_220130 _1279621;
_1279621 = bh_lower_1279617.e1;
if (_1279619) goto l1279620; else goto l1279714;
l1279714: ;
bool _1279715;
_1279715 = _1279618 == 1;
if (_1279715) goto l1279716; else goto l1279718;
l1279718: ;
// bottom: float r4_1265918_6762;
// bottom: p_1279632 = r4_1265918_6762;
goto l1279630;
l1279716: ;
float c_1279717;
c_1279717 = _1279621.pf32;
p_1279632 = c_1279717;
goto l1279630;
l1279620: ;
int y_1279622;
y_1279622 = _1279621.qs32;
int _1279623;
_1279623 = y_1279622 * _1279580;
int _1279624;
_1279624 = _1279623 + gid_x_1279583;
int _1279625;
_1279625 = 127 + _1279624;
float* idx_1279626;
idx_1279626 = _1011170_1279545 + _1279625;
_1279629 = __ldg(idx_1279626);
p_1279629 = _1279629;
l1279627: ;
_1279629 = p_1279629;
p_1279632 = _1279629;
goto l1279630;
l1279630: ;
_1279632 = p_1279632;
if (_1279570) goto l1279633; else goto l1279711;
l1279711: ;
pbh_lower_1279636 = _1279713;
goto l1279634;
l1279633: ;
union variant_220130 _1265919_6764;
_1265919_6764.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6766;
_1265920_6766.e0 = 1;
_1265920_6766.e1 = _1265919_6764;
pbh_lower_1279636 = _1265920_6766;
goto l1279634;
l1279634: ;
bh_lower_1279636 = pbh_lower_1279636;
unsigned int _1279637;
_1279637 = bh_lower_1279636.e0;
bool _1279638;
_1279638 = _1279637 == 0;
union variant_220130 _1279640;
_1279640 = bh_lower_1279636.e1;
if (_1279638) goto l1279639; else goto l1279706;
l1279706: ;
bool _1279707;
_1279707 = _1279637 == 1;
if (_1279707) goto l1279708; else goto l1279710;
l1279710: ;
// bottom: float r4_1265918_6774;
// bottom: p_1279651 = r4_1265918_6774;
goto l1279649;
l1279708: ;
float c_1279709;
c_1279709 = _1279640.pf32;
p_1279651 = c_1279709;
goto l1279649;
l1279639: ;
int y_1279641;
y_1279641 = _1279640.qs32;
int _1279642;
_1279642 = y_1279641 * _1279580;
int _1279643;
_1279643 = _1279642 + gid_x_1279583;
int _1279644;
_1279644 = 129 + _1279643;
float* idx_1279645;
idx_1279645 = _1011170_1279545 + _1279644;
_1279648 = __ldg(idx_1279645);
p_1279648 = _1279648;
l1279646: ;
_1279648 = p_1279648;
p_1279651 = _1279648;
goto l1279649;
l1279649: ;
_1279651 = p_1279651;
int _1279652;
_1279652 = 1 + gid_y_1279569;
bool _1279653;
_1279653 = _1279652 < 0;
if (_1279653) goto l1279654; else goto l1279703;
l1279703: ;
union variant_220130 _1279704;
_1279704.qs32 = _1279652;
struct_BoundaryMode_220129 _1279705;
_1279705.e0 = 0;
_1279705.e1 = _1279704;
pbh_lower_1279657 = _1279705;
goto l1279655;
l1279654: ;
union variant_220130 _1265919_6781;
_1265919_6781.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6783;
_1265920_6783.e0 = 1;
_1265920_6783.e1 = _1265919_6781;
pbh_lower_1279657 = _1265920_6783;
goto l1279655;
l1279655: ;
bh_lower_1279657 = pbh_lower_1279657;
unsigned int _1279658;
_1279658 = bh_lower_1279657.e0;
union variant_220130 _1279661;
_1279661 = bh_lower_1279657.e1;
bool _1279659;
_1279659 = _1279658 == 0;
if (_1279659) goto l1279660; else goto l1279698;
l1279698: ;
bool _1279699;
_1279699 = _1279658 == 1;
if (_1279699) goto l1279700; else goto l1279702;
l1279702: ;
// bottom: float r4_1265918_6791;
// bottom: p_1279672 = r4_1265918_6791;
goto l1279670;
l1279700: ;
float c_1279701;
c_1279701 = _1279661.pf32;
p_1279672 = c_1279701;
goto l1279670;
l1279660: ;
int y_1279662;
y_1279662 = _1279661.qs32;
int _1279663;
_1279663 = y_1279662 * _1279580;
int _1279664;
_1279664 = _1279663 + gid_x_1279583;
int _1279665;
_1279665 = 128 + _1279664;
float* idx_1279666;
idx_1279666 = _1011170_1279545 + _1279665;
_1279669 = __ldg(idx_1279666);
p_1279669 = _1279669;
l1279667: ;
_1279669 = p_1279669;
p_1279672 = _1279669;
goto l1279670;
l1279670: ;
_1279672 = p_1279672;
int _1279673;
_1279673 = _1011169_1279544.e3;
float _1279690;
_1279690 = 2.500000e-01f * _1279632;
float _1279678;
_1279678 = 2.000000e-01f * _1279592;
float _1279685;
_1279685 = _1279684;
int _1279674;
_1279674 = gid_y_1279569 * _1279673;
float _1279692;
_1279692 = 2.500000e-01f * _1279651;
float _1279694;
_1279694 = 2.500000e-01f * _1279672;
float _1279688;
_1279688 = 2.500000e-01f * _1279613;
float _1279689;
_1279689 = 0.000000e+00f + _1279688;
float _1279691;
_1279691 = _1279689 + _1279690;
float _1279686;
_1279686 = 2.000000e-01f * _1279685;
int _1279675;
_1279675 = _1279674 + gid_x_1279583;
float _1279693;
_1279693 = _1279691 + _1279692;
float _1279695;
_1279695 = _1279693 + _1279694;
float _1279687;
_1279687 = _1279678 + _1279686;
int _1279676;
_1279676 = 128 + _1279675;
float val_1279696;
val_1279696 = _1279687 + _1279695;
float* idx_1279677;
idx_1279677 = _1011168_1279543 + _1279676;
*idx_1279677 = val_1279696;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1040686(struct_Img_220118 _1040689_1277603, struct_Img_220118 _1040690_1277604, float* _1040691_1277605, struct_Img_220118 _1040692_1277606, float* _1040693_1277607, float* _1040694_1277608) {
int _1277611;
int p_1277611;
int _1277614;
int p_1277614;
int _1277617;
int p_1277617;
int _1277620;
int p_1277620;
int _1277623;
int p_1277623;
int _1277626;
int p_1277626;
int _1277629;
int p_1277629;
struct_BoundaryMode_220129 bh_upper_1277640;
struct_BoundaryMode_220129 pbh_upper_1277640;
struct_BoundaryMode_220129 bh_lower_1277647;
struct_BoundaryMode_220129 pbh_lower_1277647;
float _1277664;
float p_1277664;
float _1277667;
float p_1277667;
struct_BoundaryMode_220129 bh_upper_1277671;
struct_BoundaryMode_220129 pbh_upper_1277671;
struct_BoundaryMode_220129 bh_lower_1277677;
struct_BoundaryMode_220129 pbh_lower_1277677;
float _1277693;
float p_1277693;
float _1277696;
float p_1277696;
struct_BoundaryMode_220129 bh_upper_1277702;
struct_BoundaryMode_220129 pbh_upper_1277702;
struct_BoundaryMode_220129 bh_lower_1277706;
struct_BoundaryMode_220129 pbh_lower_1277706;
float _1277722;
float p_1277722;
float _1277725;
float p_1277725;
struct_BoundaryMode_220129 bh_upper_1277731;
struct_BoundaryMode_220129 pbh_upper_1277731;
struct_BoundaryMode_220129 bh_lower_1277735;
struct_BoundaryMode_220129 pbh_lower_1277735;
float _1277751;
float p_1277751;
float _1277754;
float p_1277754;
struct_BoundaryMode_220129 bh_upper_1277758;
struct_BoundaryMode_220129 pbh_upper_1277758;
struct_BoundaryMode_220129 bh_lower_1277764;
struct_BoundaryMode_220129 pbh_lower_1277764;
float _1277780;
float p_1277780;
float _1277783;
float p_1277783;
_1277611 = threadIdx_x();
p_1277611 = _1277611;
l1277609: ;
_1277611 = p_1277611;
_1277614 = blockDim_x();
p_1277614 = _1277614;
l1277612: ;
_1277614 = p_1277614;
_1277617 = blockIdx_x();
p_1277617 = _1277617;
l1277615: ;
_1277617 = p_1277617;
_1277620 = threadIdx_y();
p_1277620 = _1277620;
l1277618: ;
_1277620 = p_1277620;
_1277623 = blockDim_y();
p_1277623 = _1277623;
l1277621: ;
_1277623 = p_1277623;
_1277626 = blockIdx_y();
p_1277626 = _1277626;
l1277624: ;
_1277626 = p_1277626;
_1277629 = blockDim_y();
p_1277629 = _1277629;
l1277627: ;
_1277629 = p_1277629;
int _1277630;
_1277630 = _1040689_1277603.e1;
int _1277634;
_1277634 = _1277614 * _1277617;
int _1277631;
_1277631 = _1040690_1277604.e1;
int _1277632;
_1277632 = _1277631 - 128;
int _1277633;
_1277633 = _1277632 + _1277611;
int gid_x_1277635;
gid_x_1277635 = _1277633 + _1277634;
bool _1277636;
_1277636 = _1277630 <= gid_x_1277635;
union variant_220130 _1277820;
_1277820.qs32 = gid_x_1277635;
struct_BoundaryMode_220129 _1277821;
_1277821.e0 = 0;
_1277821.e1 = _1277820;
if (_1277636) goto l1277637; else goto l1277874;
l1277874: ;
pbh_upper_1277640 = _1277821;
goto l1277638;
l1277637: ;
union variant_220130 _1265919_6808;
_1265919_6808.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6810;
_1265920_6810.e0 = 1;
_1265920_6810.e1 = _1265919_6808;
pbh_upper_1277640 = _1265920_6810;
goto l1277638;
l1277638: ;
bh_upper_1277640 = pbh_upper_1277640;
int _1277641;
_1277641 = _1277623 * _1277626;
int gid_y_1277642;
gid_y_1277642 = _1277620 + _1277641;
union variant_220130 _1277832;
_1277832.qs32 = gid_y_1277642;
bool _1277643;
_1277643 = gid_y_1277642 < 0;
struct_BoundaryMode_220129 _1277833;
_1277833.e0 = 0;
_1277833.e1 = _1277832;
if (_1277643) goto l1277644; else goto l1277873;
l1277873: ;
pbh_lower_1277647 = _1277833;
goto l1277645;
l1277644: ;
union variant_220130 _1265919_6818;
_1265919_6818.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6820;
_1265920_6820.e0 = 1;
_1265920_6820.e1 = _1265919_6818;
pbh_lower_1277647 = _1265920_6820;
goto l1277645;
l1277645: ;
bh_lower_1277647 = pbh_lower_1277647;
unsigned int _1277648;
_1277648 = bh_upper_1277640.e0;
int _1277656;
_1277656 = _1040689_1277603.e3;
unsigned int _1277650;
_1277650 = bh_lower_1277647.e0;
union variant_220130 _1277658;
_1277658 = bh_upper_1277640.e1;
bool _1277651;
_1277651 = _1277650 == 0;
union variant_220130 _1277654;
_1277654 = bh_lower_1277647.e1;
bool _1277649;
_1277649 = _1277648 == 0;
bool _1277652;
_1277652 = _1277649 & _1277651;
if (_1277652) goto l1277653; else goto l1277864;
l1277864: ;
bool _1277865;
_1277865 = _1277648 == 1;
if (_1277865) goto l1277866; else goto l1277868;
l1277868: ;
bool _1277869;
_1277869 = _1277650 == 1;
if (_1277869) goto l1277870; else goto l1277872;
l1277872: ;
// bottom: float r4_1265918_6833;
// bottom: p_1277667 = r4_1265918_6833;
goto l1277665;
l1277870: ;
float c_1277871;
c_1277871 = _1277654.pf32;
p_1277667 = c_1277871;
goto l1277665;
l1277866: ;
float c_1277867;
c_1277867 = _1277658.pf32;
p_1277667 = c_1277867;
goto l1277665;
l1277653: ;
int x_1277659;
x_1277659 = _1277658.qs32;
int y_1277655;
y_1277655 = _1277654.qs32;
int _1277657;
_1277657 = y_1277655 * _1277656;
int _1277660;
_1277660 = _1277657 + x_1277659;
float* idx_1277661;
idx_1277661 = _1040691_1277605 + _1277660;
_1277664 = __ldg(idx_1277661);
p_1277664 = _1277664;
l1277662: ;
_1277664 = p_1277664;
p_1277667 = _1277664;
goto l1277665;
l1277665: ;
_1277667 = p_1277667;
int _1277789;
_1277789 = _1040692_1277606.e3;
int _1277790;
_1277790 = gid_y_1277642 * _1277789;
int _1277791;
_1277791 = _1277790 + gid_x_1277635;
float* idx_1277792;
idx_1277792 = _1040694_1277608 + _1277791;
float _1277793;
_1277793 = *idx_1277792;
if (_1277636) goto l1277668; else goto l1277863;
l1277863: ;
pbh_upper_1277671 = _1277821;
goto l1277669;
l1277668: ;
union variant_220130 _1265919_6835;
_1265919_6835.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6837;
_1265920_6837.e0 = 1;
_1265920_6837.e1 = _1265919_6835;
pbh_upper_1277671 = _1265920_6837;
goto l1277669;
l1277669: ;
bh_upper_1277671 = pbh_upper_1277671;
int _1277672;
_1277672 = -1 + gid_y_1277642;
bool _1277673;
_1277673 = _1277672 < 0;
if (_1277673) goto l1277674; else goto l1277859;
l1277859: ;
union variant_220130 _1277860;
_1277860.qs32 = _1277672;
struct_BoundaryMode_220129 _1277861;
_1277861.e0 = 0;
_1277861.e1 = _1277860;
pbh_lower_1277677 = _1277861;
goto l1277675;
l1277674: ;
union variant_220130 _1265919_6846;
_1265919_6846.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6848;
_1265920_6848.e0 = 1;
_1265920_6848.e1 = _1265919_6846;
pbh_lower_1277677 = _1265920_6848;
goto l1277675;
l1277675: ;
bh_lower_1277677 = pbh_lower_1277677;
union variant_220130 _1277687;
_1277687 = bh_upper_1277671.e1;
union variant_220130 _1277684;
_1277684 = bh_lower_1277677.e1;
unsigned int _1277680;
_1277680 = bh_lower_1277677.e0;
unsigned int _1277678;
_1277678 = bh_upper_1277671.e0;
bool _1277681;
_1277681 = _1277680 == 0;
bool _1277679;
_1277679 = _1277678 == 0;
bool _1277682;
_1277682 = _1277679 & _1277681;
if (_1277682) goto l1277683; else goto l1277850;
l1277850: ;
bool _1277851;
_1277851 = _1277678 == 1;
if (_1277851) goto l1277852; else goto l1277854;
l1277854: ;
bool _1277855;
_1277855 = _1277680 == 1;
if (_1277855) goto l1277856; else goto l1277858;
l1277858: ;
// bottom: float r4_1265918_6860;
// bottom: p_1277696 = r4_1265918_6860;
goto l1277694;
l1277856: ;
float c_1277857;
c_1277857 = _1277684.pf32;
p_1277696 = c_1277857;
goto l1277694;
l1277852: ;
float c_1277853;
c_1277853 = _1277687.pf32;
p_1277696 = c_1277853;
goto l1277694;
l1277683: ;
int y_1277685;
y_1277685 = _1277684.qs32;
int _1277686;
_1277686 = y_1277685 * _1277656;
int x_1277688;
x_1277688 = _1277687.qs32;
int _1277689;
_1277689 = _1277686 + x_1277688;
float* idx_1277690;
idx_1277690 = _1040691_1277605 + _1277689;
_1277693 = __ldg(idx_1277690);
p_1277693 = _1277693;
l1277691: ;
_1277693 = p_1277693;
p_1277696 = _1277693;
goto l1277694;
l1277694: ;
_1277696 = p_1277696;
int _1277697;
_1277697 = -1 + gid_x_1277635;
bool _1277698;
_1277698 = _1277630 <= _1277697;
if (_1277698) goto l1277699; else goto l1277847;
l1277847: ;
union variant_220130 _1277848;
_1277848.qs32 = _1277697;
struct_BoundaryMode_220129 _1277849;
_1277849.e0 = 0;
_1277849.e1 = _1277848;
pbh_upper_1277702 = _1277849;
goto l1277700;
l1277699: ;
union variant_220130 _1265919_6865;
_1265919_6865.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6867;
_1265920_6867.e0 = 1;
_1265920_6867.e1 = _1265919_6865;
pbh_upper_1277702 = _1265920_6867;
goto l1277700;
l1277700: ;
bh_upper_1277702 = pbh_upper_1277702;
if (_1277643) goto l1277703; else goto l1277846;
l1277846: ;
pbh_lower_1277706 = _1277833;
goto l1277704;
l1277703: ;
union variant_220130 _1265919_6871;
_1265919_6871.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6873;
_1265920_6873.e0 = 1;
_1265920_6873.e1 = _1265919_6871;
pbh_lower_1277706 = _1265920_6873;
goto l1277704;
l1277704: ;
bh_lower_1277706 = pbh_lower_1277706;
union variant_220130 _1277713;
_1277713 = bh_lower_1277706.e1;
union variant_220130 _1277716;
_1277716 = bh_upper_1277702.e1;
unsigned int _1277707;
_1277707 = bh_upper_1277702.e0;
unsigned int _1277709;
_1277709 = bh_lower_1277706.e0;
bool _1277708;
_1277708 = _1277707 == 0;
bool _1277710;
_1277710 = _1277709 == 0;
bool _1277711;
_1277711 = _1277708 & _1277710;
if (_1277711) goto l1277712; else goto l1277837;
l1277837: ;
bool _1277838;
_1277838 = _1277707 == 1;
if (_1277838) goto l1277839; else goto l1277841;
l1277841: ;
bool _1277842;
_1277842 = _1277709 == 1;
if (_1277842) goto l1277843; else goto l1277845;
l1277845: ;
// bottom: float r4_1265918_6885;
// bottom: p_1277725 = r4_1265918_6885;
goto l1277723;
l1277843: ;
float c_1277844;
c_1277844 = _1277713.pf32;
p_1277725 = c_1277844;
goto l1277723;
l1277839: ;
float c_1277840;
c_1277840 = _1277716.pf32;
p_1277725 = c_1277840;
goto l1277723;
l1277712: ;
int x_1277717;
x_1277717 = _1277716.qs32;
int y_1277714;
y_1277714 = _1277713.qs32;
int _1277715;
_1277715 = y_1277714 * _1277656;
int _1277718;
_1277718 = _1277715 + x_1277717;
float* idx_1277719;
idx_1277719 = _1040691_1277605 + _1277718;
_1277722 = __ldg(idx_1277719);
p_1277722 = _1277722;
l1277720: ;
_1277722 = p_1277722;
p_1277725 = _1277722;
goto l1277723;
l1277723: ;
_1277725 = p_1277725;
int _1277726;
_1277726 = 1 + gid_x_1277635;
bool _1277727;
_1277727 = _1277630 <= _1277726;
if (_1277727) goto l1277728; else goto l1277834;
l1277834: ;
union variant_220130 _1277835;
_1277835.qs32 = _1277726;
struct_BoundaryMode_220129 _1277836;
_1277836.e0 = 0;
_1277836.e1 = _1277835;
pbh_upper_1277731 = _1277836;
goto l1277729;
l1277728: ;
union variant_220130 _1265919_6890;
_1265919_6890.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6892;
_1265920_6892.e0 = 1;
_1265920_6892.e1 = _1265919_6890;
pbh_upper_1277731 = _1265920_6892;
goto l1277729;
l1277729: ;
bh_upper_1277731 = pbh_upper_1277731;
if (_1277643) goto l1277732; else goto l1277831;
l1277831: ;
pbh_lower_1277735 = _1277833;
goto l1277733;
l1277732: ;
union variant_220130 _1265919_6896;
_1265919_6896.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6898;
_1265920_6898.e0 = 1;
_1265920_6898.e1 = _1265919_6896;
pbh_lower_1277735 = _1265920_6898;
goto l1277733;
l1277733: ;
bh_lower_1277735 = pbh_lower_1277735;
unsigned int _1277736;
_1277736 = bh_upper_1277731.e0;
unsigned int _1277738;
_1277738 = bh_lower_1277735.e0;
union variant_220130 _1277745;
_1277745 = bh_upper_1277731.e1;
union variant_220130 _1277742;
_1277742 = bh_lower_1277735.e1;
bool _1277739;
_1277739 = _1277738 == 0;
bool _1277737;
_1277737 = _1277736 == 0;
bool _1277740;
_1277740 = _1277737 & _1277739;
if (_1277740) goto l1277741; else goto l1277822;
l1277822: ;
bool _1277823;
_1277823 = _1277736 == 1;
if (_1277823) goto l1277824; else goto l1277826;
l1277826: ;
bool _1277827;
_1277827 = _1277738 == 1;
if (_1277827) goto l1277828; else goto l1277830;
l1277830: ;
// bottom: float r4_1265918_6910;
// bottom: p_1277754 = r4_1265918_6910;
goto l1277752;
l1277828: ;
float c_1277829;
c_1277829 = _1277742.pf32;
p_1277754 = c_1277829;
goto l1277752;
l1277824: ;
float c_1277825;
c_1277825 = _1277745.pf32;
p_1277754 = c_1277825;
goto l1277752;
l1277741: ;
int y_1277743;
y_1277743 = _1277742.qs32;
int x_1277746;
x_1277746 = _1277745.qs32;
int _1277744;
_1277744 = y_1277743 * _1277656;
int _1277747;
_1277747 = _1277744 + x_1277746;
float* idx_1277748;
idx_1277748 = _1040691_1277605 + _1277747;
_1277751 = __ldg(idx_1277748);
p_1277751 = _1277751;
l1277749: ;
_1277751 = p_1277751;
p_1277754 = _1277751;
goto l1277752;
l1277752: ;
_1277754 = p_1277754;
if (_1277636) goto l1277755; else goto l1277819;
l1277819: ;
pbh_upper_1277758 = _1277821;
goto l1277756;
l1277755: ;
union variant_220130 _1265919_6911;
_1265919_6911.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6913;
_1265920_6913.e0 = 1;
_1265920_6913.e1 = _1265919_6911;
pbh_upper_1277758 = _1265920_6913;
goto l1277756;
l1277756: ;
bh_upper_1277758 = pbh_upper_1277758;
int _1277759;
_1277759 = 1 + gid_y_1277642;
bool _1277760;
_1277760 = _1277759 < 0;
if (_1277760) goto l1277761; else goto l1277816;
l1277816: ;
union variant_220130 _1277817;
_1277817.qs32 = _1277759;
struct_BoundaryMode_220129 _1277818;
_1277818.e0 = 0;
_1277818.e1 = _1277817;
pbh_lower_1277764 = _1277818;
goto l1277762;
l1277761: ;
union variant_220130 _1265919_6922;
_1265919_6922.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_6924;
_1265920_6924.e0 = 1;
_1265920_6924.e1 = _1265919_6922;
pbh_lower_1277764 = _1265920_6924;
goto l1277762;
l1277762: ;
bh_lower_1277764 = pbh_lower_1277764;
union variant_220130 _1277774;
_1277774 = bh_upper_1277758.e1;
unsigned int _1277767;
_1277767 = bh_lower_1277764.e0;
unsigned int _1277765;
_1277765 = bh_upper_1277758.e0;
union variant_220130 _1277771;
_1277771 = bh_lower_1277764.e1;
bool _1277766;
_1277766 = _1277765 == 0;
bool _1277768;
_1277768 = _1277767 == 0;
bool _1277769;
_1277769 = _1277766 & _1277768;
if (_1277769) goto l1277770; else goto l1277807;
l1277807: ;
bool _1277808;
_1277808 = _1277765 == 1;
if (_1277808) goto l1277809; else goto l1277811;
l1277811: ;
bool _1277812;
_1277812 = _1277767 == 1;
if (_1277812) goto l1277813; else goto l1277815;
l1277815: ;
// bottom: float r4_1265918_6936;
// bottom: p_1277783 = r4_1265918_6936;
goto l1277781;
l1277813: ;
float c_1277814;
c_1277814 = _1277771.pf32;
p_1277783 = c_1277814;
goto l1277781;
l1277809: ;
float c_1277810;
c_1277810 = _1277774.pf32;
p_1277783 = c_1277810;
goto l1277781;
l1277770: ;
int x_1277775;
x_1277775 = _1277774.qs32;
int y_1277772;
y_1277772 = _1277771.qs32;
int _1277773;
_1277773 = y_1277772 * _1277656;
int _1277776;
_1277776 = _1277773 + x_1277775;
float* idx_1277777;
idx_1277777 = _1040691_1277605 + _1277776;
_1277780 = __ldg(idx_1277777);
p_1277780 = _1277780;
l1277778: ;
_1277780 = p_1277780;
p_1277783 = _1277780;
goto l1277781;
l1277781: ;
_1277783 = p_1277783;
float _1277803;
_1277803 = 2.500000e-01f * _1277783;
int _1277784;
_1277784 = _1040690_1277604.e3;
float _1277788;
_1277788 = 2.000000e-01f * _1277667;
int _1277785;
_1277785 = gid_y_1277642 * _1277784;
float _1277797;
_1277797 = 2.500000e-01f * _1277696;
float _1277799;
_1277799 = 2.500000e-01f * _1277725;
float _1277801;
_1277801 = 2.500000e-01f * _1277754;
float _1277794;
_1277794 = _1277793;
int _1277786;
_1277786 = _1277785 + gid_x_1277635;
float _1277798;
_1277798 = 0.000000e+00f + _1277797;
float _1277800;
_1277800 = _1277798 + _1277799;
float _1277802;
_1277802 = _1277800 + _1277801;
float _1277795;
_1277795 = 2.000000e-01f * _1277794;
float* idx_1277787;
idx_1277787 = _1040693_1277607 + _1277786;
float _1277804;
_1277804 = _1277802 + _1277803;
float _1277796;
_1277796 = _1277788 + _1277795;
float val_1277805;
val_1277805 = _1277796 + _1277804;
*idx_1277787 = val_1277805;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1021390(float* _1021393_1265956, struct_Img_220118 _1021394_1265957, float* _1021395_1265958, float* _1021396_1265959, struct_Img_220118 _1021397_1265960, struct_Img_220118 _1021398_1265961) {
int _1265964;
int p_1265964;
int _1265967;
int p_1265967;
int _1265970;
int p_1265970;
int _1265973;
int p_1265973;
int _1265976;
int p_1265976;
int _1265979;
int p_1265979;
int _1265982;
int p_1265982;
float _1265995;
float p_1265995;
float _1266009;
float p_1266009;
float _1266015;
float p_1266015;
float _1266021;
float p_1266021;
float _1266029;
float p_1266029;
_1265964 = threadIdx_x();
p_1265964 = _1265964;
l1265962: ;
_1265964 = p_1265964;
_1265967 = blockDim_x();
p_1265967 = _1265967;
l1265965: ;
_1265967 = p_1265967;
_1265970 = blockIdx_x();
p_1265970 = _1265970;
l1265968: ;
_1265970 = p_1265970;
_1265973 = threadIdx_y();
p_1265973 = _1265973;
l1265971: ;
_1265973 = p_1265973;
_1265976 = blockDim_y();
p_1265976 = _1265976;
l1265974: ;
_1265976 = p_1265976;
_1265979 = blockIdx_y();
p_1265979 = _1265979;
l1265977: ;
_1265979 = p_1265979;
_1265982 = blockDim_y();
p_1265982 = _1265982;
l1265980: ;
_1265982 = p_1265982;
int _1265986;
_1265986 = _1021397_1265960.e3;
int _1265983;
_1265983 = _1265976 * _1265979;
int _1265988;
_1265988 = _1265967 * _1265970;
int gid_y_1265984;
gid_y_1265984 = _1265973 + _1265983;
int gid_x_1265989;
gid_x_1265989 = _1265964 + _1265988;
int _1265985;
_1265985 = 1 + gid_y_1265984;
int _1265987;
_1265987 = _1265985 * _1265986;
int _1265990;
_1265990 = _1265987 + gid_x_1265989;
int _1265991;
_1265991 = 128 + _1265990;
float* idx_1265992;
idx_1265992 = _1021396_1265959 + _1265991;
_1265995 = __ldg(idx_1265992);
p_1265995 = _1265995;
l1265993: ;
_1265995 = p_1265995;
int _1266003;
_1266003 = gid_y_1265984 * _1265986;
int _1266004;
_1266004 = _1266003 + gid_x_1265989;
int _1265996;
_1265996 = _1021398_1265961.e3;
int _1266005;
_1266005 = 128 + _1266004;
int _1265997;
_1265997 = _1265985 * _1265996;
float* idx_1266006;
idx_1266006 = _1021396_1265959 + _1266005;
int _1265998;
_1265998 = _1265997 + gid_x_1265989;
int _1265999;
_1265999 = 128 + _1265998;
float* idx_1266000;
idx_1266000 = _1021393_1265956 + _1265999;
float _1266001;
_1266001 = *idx_1266000;
_1266009 = __ldg(idx_1266006);
p_1266009 = _1266009;
l1266007: ;
_1266009 = p_1266009;
int _1266011;
_1266011 = 127 + _1265990;
float* idx_1266012;
idx_1266012 = _1021396_1265959 + _1266011;
_1266015 = __ldg(idx_1266012);
p_1266015 = _1266015;
l1266013: ;
_1266015 = p_1266015;
int _1266017;
_1266017 = 129 + _1265990;
float* idx_1266018;
idx_1266018 = _1021396_1265959 + _1266017;
_1266021 = __ldg(idx_1266018);
p_1266021 = _1266021;
l1266019: ;
_1266021 = p_1266021;
int _1266022;
_1266022 = 2 + gid_y_1265984;
int _1266023;
_1266023 = _1266022 * _1265986;
int _1266024;
_1266024 = _1266023 + gid_x_1265989;
int _1266025;
_1266025 = 128 + _1266024;
float* idx_1266026;
idx_1266026 = _1021396_1265959 + _1266025;
_1266029 = __ldg(idx_1266026);
p_1266029 = _1266029;
l1266027: ;
_1266029 = p_1266029;
int _1266030;
_1266030 = _1021394_1265957.e3;
float _1266035;
_1266035 = 2.000000e-01f * _1265995;
float _1266041;
_1266041 = 2.500000e-01f * _1266015;
float _1266045;
_1266045 = 2.500000e-01f * _1266029;
float _1266036;
_1266036 = _1266001;
float _1266039;
_1266039 = 2.500000e-01f * _1266009;
float _1266043;
_1266043 = 2.500000e-01f * _1266021;
int _1266031;
_1266031 = _1265985 * _1266030;
float _1266037;
_1266037 = 2.000000e-01f * _1266036;
float _1266040;
_1266040 = 0.000000e+00f + _1266039;
int _1266032;
_1266032 = _1266031 + gid_x_1265989;
float _1266038;
_1266038 = _1266035 + _1266037;
float _1266042;
_1266042 = _1266040 + _1266041;
int _1266033;
_1266033 = 128 + _1266032;
float _1266044;
_1266044 = _1266042 + _1266043;
float* idx_1266034;
idx_1266034 = _1021395_1265958 + _1266033;
float _1266046;
_1266046 = _1266044 + _1266045;
float val_1266047;
val_1266047 = _1266038 + _1266046;
*idx_1266034 = val_1266047;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_997650(float* _997653_1276295, float* _997654_1276296, int _997655_1276297) {
int _1276300;
int p_1276300;
int _1276303;
int p_1276303;
int _1276306;
int p_1276306;
int _1276309;
int p_1276309;
int _1276312;
int p_1276312;
int _1276315;
int p_1276315;
int _1276318;
int p_1276318;
float _1276329;
float p_1276329;
float _1276337;
float p_1276337;
float _1276342;
float p_1276342;
float _1276347;
float p_1276347;
float _1276355;
float p_1276355;
_1276300 = threadIdx_x();
p_1276300 = _1276300;
l1276298: ;
_1276300 = p_1276300;
_1276303 = blockDim_x();
p_1276303 = _1276303;
l1276301: ;
_1276303 = p_1276303;
_1276306 = blockIdx_x();
p_1276306 = _1276306;
l1276304: ;
_1276306 = p_1276306;
_1276309 = threadIdx_y();
p_1276309 = _1276309;
l1276307: ;
_1276309 = p_1276309;
_1276312 = blockDim_y();
p_1276312 = _1276312;
l1276310: ;
_1276312 = p_1276312;
_1276315 = blockIdx_y();
p_1276315 = _1276315;
l1276313: ;
_1276315 = p_1276315;
_1276318 = blockDim_y();
p_1276318 = _1276318;
l1276316: ;
_1276318 = p_1276318;
int _1276322;
_1276322 = _1276303 * _1276306;
int _1276319;
_1276319 = _1276312 * _1276315;
int gid_y_1276320;
gid_y_1276320 = _1276309 + _1276319;
int gid_x_1276323;
gid_x_1276323 = _1276300 + _1276322;
int _1276321;
_1276321 = gid_y_1276320 * _997655_1276297;
int _1276324;
_1276324 = _1276321 + gid_x_1276323;
int _1276325;
_1276325 = 128 + _1276324;
float* idx_1276326;
idx_1276326 = _997653_1276295 + _1276325;
_1276329 = __ldg(idx_1276326);
p_1276329 = _1276329;
l1276327: ;
_1276329 = p_1276329;
int _1276330;
_1276330 = 1 + gid_y_1276320;
int _1276331;
_1276331 = _1276330 * _997655_1276297;
int _1276332;
_1276332 = _1276331 + gid_x_1276323;
int _1276333;
_1276333 = 127 + _1276332;
float* idx_1276334;
idx_1276334 = _997653_1276295 + _1276333;
_1276337 = __ldg(idx_1276334);
p_1276337 = _1276337;
l1276335: ;
_1276337 = p_1276337;
int _1276338;
_1276338 = 128 + _1276332;
float* idx_1276339;
idx_1276339 = _997653_1276295 + _1276338;
_1276342 = __ldg(idx_1276339);
p_1276342 = _1276342;
l1276340: ;
_1276342 = p_1276342;
int _1276343;
_1276343 = 129 + _1276332;
float* idx_1276344;
idx_1276344 = _997653_1276295 + _1276343;
_1276347 = __ldg(idx_1276344);
p_1276347 = _1276347;
l1276345: ;
_1276347 = p_1276347;
int _1276348;
_1276348 = 2 + gid_y_1276320;
int _1276349;
_1276349 = _1276348 * _997655_1276297;
int _1276350;
_1276350 = _1276349 + gid_x_1276323;
int _1276351;
_1276351 = 128 + _1276350;
float* idx_1276352;
idx_1276352 = _997653_1276295 + _1276351;
_1276355 = __ldg(idx_1276352);
p_1276355 = _1276355;
l1276353: ;
_1276355 = p_1276355;
float _1276374;
_1276374 = 1.000000e+00f * _1276355;
float _1276368;
_1276368 = 1.000000e+00f * _1276337;
float _1276372;
_1276372 = 1.000000e+00f * _1276347;
float _1276366;
_1276366 = 1.000000e+00f * _1276329;
float _1276370;
_1276370 = -4.000000e+00f * _1276342;
int _1276356;
_1276356 = 4 * _997655_1276297;
float _1276367;
_1276367 = 0.000000e+00f + _1276366;
int _1276357;
_1276357 = 64 + _1276356;
float _1276369;
_1276369 = _1276367 + _1276368;
int _1276358;
_1276358 = _1276357 - 1;
float _1276371;
_1276371 = _1276369 + _1276370;
int _1276359;
_1276359 = _1276358 / 64;
float _1276373;
_1276373 = _1276371 + _1276372;
int _1276360;
_1276360 = 64 * _1276359;
float _1276375;
_1276375 = _1276373 + _1276374;
int stride_1276361;
stride_1276361 = _1276360 / 4;
int _1276362;
_1276362 = _1276330 * stride_1276361;
int _1276363;
_1276363 = _1276362 + gid_x_1276323;
int _1276364;
_1276364 = 128 + _1276363;
float* idx_1276365;
idx_1276365 = _997654_1276296 + _1276364;
*idx_1276365 = _1276375;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_996843(float* _996846_1281147, float* _996847_1281148, int _996848_1281149, int _996849_1281150) {
int _1281153;
int p_1281153;
int _1281156;
int p_1281156;
int _1281159;
int p_1281159;
int _1281162;
int p_1281162;
int _1281165;
int p_1281165;
int _1281168;
int p_1281168;
int _1281171;
int p_1281171;
int converge_1281177;
int pconverge_1281177;
int converge_1281186;
int pconverge_1281186;
float _1281192;
float p_1281192;
int converge_1281197;
int pconverge_1281197;
int converge_1281201;
int pconverge_1281201;
float _1281207;
float p_1281207;
int converge_1281210;
int pconverge_1281210;
int converge_1281213;
int pconverge_1281213;
float _1281219;
float p_1281219;
int converge_1281224;
int pconverge_1281224;
int converge_1281227;
int pconverge_1281227;
float _1281233;
float p_1281233;
int converge_1281236;
int pconverge_1281236;
int converge_1281241;
int pconverge_1281241;
float _1281247;
float p_1281247;
_1281153 = threadIdx_x();
p_1281153 = _1281153;
l1281151: ;
_1281153 = p_1281153;
_1281156 = blockDim_x();
p_1281156 = _1281156;
l1281154: ;
_1281156 = p_1281156;
_1281159 = blockIdx_x();
p_1281159 = _1281159;
l1281157: ;
_1281159 = p_1281159;
_1281162 = threadIdx_y();
p_1281162 = _1281162;
l1281160: ;
_1281162 = p_1281162;
_1281165 = blockDim_y();
p_1281165 = _1281165;
l1281163: ;
_1281165 = p_1281165;
_1281168 = blockIdx_y();
p_1281168 = _1281168;
l1281166: ;
_1281168 = p_1281168;
_1281171 = blockDim_y();
p_1281171 = _1281171;
l1281169: ;
_1281171 = p_1281171;
int _1281172;
_1281172 = _1281156 * _1281159;
int gid_x_1281173;
gid_x_1281173 = _1281153 + _1281172;
int _1281272;
_1281272 = 0 - gid_x_1281173;
bool _1281174;
_1281174 = gid_x_1281173 < 0;
int _1281273;
_1281273 = _1281272 - 1;
if (_1281174) goto l1281175; else goto l1281290;
l1281290: ;
pconverge_1281177 = gid_x_1281173;
goto l1281176;
l1281175: ;
pconverge_1281177 = _1281273;
goto l1281176;
l1281176: ;
converge_1281177 = pconverge_1281177;
int _1281178;
_1281178 = _996848_1281149 - 1;
int _1281179;
_1281179 = _1281178 + _1281162;
int _1281180;
_1281180 = _1281165 * _1281168;
int gid_y_1281181;
gid_y_1281181 = _1281179 + _1281180;
int _1281182;
_1281182 = -1 + gid_y_1281181;
bool _1281183;
_1281183 = _996848_1281149 <= _1281182;
if (_1281183) goto l1281184; else goto l1281289;
l1281289: ;
pconverge_1281186 = _1281182;
goto l1281185;
l1281184: ;
int _1281287;
_1281287 = gid_y_1281181 - _996848_1281149;
int _1281288;
_1281288 = _996848_1281149 - _1281287;
pconverge_1281186 = _1281288;
goto l1281185;
l1281185: ;
converge_1281186 = pconverge_1281186;
int _1281187;
_1281187 = converge_1281186 * _996849_1281150;
int _1281188;
_1281188 = _1281187 + converge_1281177;
float* idx_1281189;
idx_1281189 = _996846_1281147 + _1281188;
_1281192 = __ldg(idx_1281189);
p_1281192 = _1281192;
l1281190: ;
_1281192 = p_1281192;
int _1281193;
_1281193 = -1 + gid_x_1281173;
bool _1281194;
_1281194 = _1281193 < 0;
if (_1281194) goto l1281195; else goto l1281286;
l1281286: ;
pconverge_1281197 = _1281193;
goto l1281196;
l1281195: ;
int _1281284;
_1281284 = 0 - _1281193;
int _1281285;
_1281285 = _1281284 - 1;
pconverge_1281197 = _1281285;
goto l1281196;
l1281196: ;
converge_1281197 = pconverge_1281197;
int _1281237;
_1281237 = 1 + gid_y_1281181;
int _1281275;
_1281275 = _1281237 - _996848_1281149;
int _1281276;
_1281276 = _996848_1281149 - _1281275;
bool _1281198;
_1281198 = _996848_1281149 <= gid_y_1281181;
if (_1281198) goto l1281199; else goto l1281283;
l1281283: ;
pconverge_1281201 = gid_y_1281181;
goto l1281200;
l1281199: ;
pconverge_1281201 = _1281276;
goto l1281200;
l1281200: ;
converge_1281201 = pconverge_1281201;
int _1281202;
_1281202 = converge_1281201 * _996849_1281150;
int _1281203;
_1281203 = _1281202 + converge_1281197;
float* idx_1281204;
idx_1281204 = _996846_1281147 + _1281203;
_1281207 = __ldg(idx_1281204);
p_1281207 = _1281207;
l1281205: ;
_1281207 = p_1281207;
if (_1281174) goto l1281208; else goto l1281282;
l1281282: ;
pconverge_1281210 = gid_x_1281173;
goto l1281209;
l1281208: ;
pconverge_1281210 = _1281273;
goto l1281209;
l1281209: ;
converge_1281210 = pconverge_1281210;
if (_1281198) goto l1281211; else goto l1281281;
l1281281: ;
pconverge_1281213 = gid_y_1281181;
goto l1281212;
l1281211: ;
pconverge_1281213 = _1281276;
goto l1281212;
l1281212: ;
converge_1281213 = pconverge_1281213;
int _1281214;
_1281214 = converge_1281213 * _996849_1281150;
int _1281215;
_1281215 = _1281214 + converge_1281210;
float* idx_1281216;
idx_1281216 = _996846_1281147 + _1281215;
_1281219 = __ldg(idx_1281216);
p_1281219 = _1281219;
l1281217: ;
_1281219 = p_1281219;
int _1281220;
_1281220 = 1 + gid_x_1281173;
bool _1281221;
_1281221 = _1281220 < 0;
if (_1281221) goto l1281222; else goto l1281280;
l1281280: ;
pconverge_1281224 = _1281220;
goto l1281223;
l1281222: ;
int _1281278;
_1281278 = 0 - _1281220;
int _1281279;
_1281279 = _1281278 - 1;
pconverge_1281224 = _1281279;
goto l1281223;
l1281223: ;
converge_1281224 = pconverge_1281224;
if (_1281198) goto l1281225; else goto l1281277;
l1281277: ;
pconverge_1281227 = gid_y_1281181;
goto l1281226;
l1281225: ;
pconverge_1281227 = _1281276;
goto l1281226;
l1281226: ;
converge_1281227 = pconverge_1281227;
int _1281228;
_1281228 = converge_1281227 * _996849_1281150;
int _1281229;
_1281229 = _1281228 + converge_1281224;
float* idx_1281230;
idx_1281230 = _996846_1281147 + _1281229;
_1281233 = __ldg(idx_1281230);
p_1281233 = _1281233;
l1281231: ;
_1281233 = p_1281233;
if (_1281174) goto l1281234; else goto l1281274;
l1281274: ;
pconverge_1281236 = gid_x_1281173;
goto l1281235;
l1281234: ;
pconverge_1281236 = _1281273;
goto l1281235;
l1281235: ;
converge_1281236 = pconverge_1281236;
bool _1281238;
_1281238 = _996848_1281149 <= _1281237;
if (_1281238) goto l1281239; else goto l1281271;
l1281271: ;
pconverge_1281241 = _1281237;
goto l1281240;
l1281239: ;
int _1281268;
_1281268 = 2 + gid_y_1281181;
int _1281269;
_1281269 = _1281268 - _996848_1281149;
int _1281270;
_1281270 = _996848_1281149 - _1281269;
pconverge_1281241 = _1281270;
goto l1281240;
l1281240: ;
converge_1281241 = pconverge_1281241;
int _1281242;
_1281242 = converge_1281241 * _996849_1281150;
int _1281243;
_1281243 = _1281242 + converge_1281236;
float* idx_1281244;
idx_1281244 = _996846_1281147 + _1281243;
_1281247 = __ldg(idx_1281244);
p_1281247 = _1281247;
l1281245: ;
_1281247 = p_1281247;
int _1281248;
_1281248 = 4 * _996849_1281150;
float _1281259;
_1281259 = 1.000000e+00f * _1281207;
float _1281257;
_1281257 = 1.000000e+00f * _1281192;
float _1281263;
_1281263 = 1.000000e+00f * _1281233;
int _1281249;
_1281249 = 64 + _1281248;
int _1281250;
_1281250 = _1281249 - 1;
float _1281261;
_1281261 = -4.000000e+00f * _1281219;
float _1281258;
_1281258 = 0.000000e+00f + _1281257;
float _1281265;
_1281265 = 1.000000e+00f * _1281247;
int _1281251;
_1281251 = _1281250 / 64;
float _1281260;
_1281260 = _1281258 + _1281259;
float _1281262;
_1281262 = _1281260 + _1281261;
int _1281252;
_1281252 = 64 * _1281251;
float _1281264;
_1281264 = _1281262 + _1281263;
int stride_1281253;
stride_1281253 = _1281252 / 4;
float _1281266;
_1281266 = _1281264 + _1281265;
int _1281254;
_1281254 = gid_y_1281181 * stride_1281253;
int _1281255;
_1281255 = _1281254 + gid_x_1281173;
float* idx_1281256;
idx_1281256 = _996847_1281148 + _1281255;
*idx_1281256 = _1281266;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1035894(float* _1035897_1277328, struct_Img_220118 _1035898_1277329, float* _1035899_1277330, struct_Img_220118 _1035900_1277331, struct_Img_220118 _1035901_1277332, float* _1035902_1277333) {
int _1277336;
int p_1277336;
int _1277339;
int p_1277339;
int _1277342;
int p_1277342;
int _1277345;
int p_1277345;
int _1277348;
int p_1277348;
int _1277351;
int p_1277351;
int _1277354;
int p_1277354;
struct_BoundaryMode_220129 bh_upper_1277365;
struct_BoundaryMode_220129 pbh_upper_1277365;
struct_BoundaryMode_220129 bh_lower_1277372;
struct_BoundaryMode_220129 pbh_lower_1277372;
float _1277389;
float p_1277389;
float _1277392;
float p_1277392;
struct_BoundaryMode_220129 bh_upper_1277396;
struct_BoundaryMode_220129 pbh_upper_1277396;
struct_BoundaryMode_220129 bh_lower_1277402;
struct_BoundaryMode_220129 pbh_lower_1277402;
float _1277418;
float p_1277418;
float _1277421;
float p_1277421;
struct_BoundaryMode_220129 bh_upper_1277427;
struct_BoundaryMode_220129 pbh_upper_1277427;
struct_BoundaryMode_220129 bh_lower_1277431;
struct_BoundaryMode_220129 pbh_lower_1277431;
float _1277447;
float p_1277447;
float _1277450;
float p_1277450;
struct_BoundaryMode_220129 bh_upper_1277456;
struct_BoundaryMode_220129 pbh_upper_1277456;
struct_BoundaryMode_220129 bh_lower_1277460;
struct_BoundaryMode_220129 pbh_lower_1277460;
float _1277476;
float p_1277476;
float _1277479;
float p_1277479;
struct_BoundaryMode_220129 bh_upper_1277483;
struct_BoundaryMode_220129 pbh_upper_1277483;
struct_BoundaryMode_220129 bh_lower_1277489;
struct_BoundaryMode_220129 pbh_lower_1277489;
float _1277505;
float p_1277505;
float _1277508;
float p_1277508;
_1277336 = threadIdx_x();
p_1277336 = _1277336;
l1277334: ;
_1277336 = p_1277336;
_1277339 = blockDim_x();
p_1277339 = _1277339;
l1277337: ;
_1277339 = p_1277339;
_1277342 = blockIdx_x();
p_1277342 = _1277342;
l1277340: ;
_1277342 = p_1277342;
_1277345 = threadIdx_y();
p_1277345 = _1277345;
l1277343: ;
_1277345 = p_1277345;
_1277348 = blockDim_y();
p_1277348 = _1277348;
l1277346: ;
_1277348 = p_1277348;
_1277351 = blockIdx_y();
p_1277351 = _1277351;
l1277349: ;
_1277351 = p_1277351;
_1277354 = blockDim_y();
p_1277354 = _1277354;
l1277352: ;
_1277354 = p_1277354;
int _1277359;
_1277359 = _1277339 * _1277342;
int _1277356;
_1277356 = _1035901_1277332.e1;
int _1277357;
_1277357 = _1277356 - 128;
int _1277355;
_1277355 = _1035900_1277331.e1;
int _1277358;
_1277358 = _1277357 + _1277336;
int gid_x_1277360;
gid_x_1277360 = _1277358 + _1277359;
union variant_220130 _1277545;
_1277545.qs32 = gid_x_1277360;
bool _1277361;
_1277361 = _1277355 <= gid_x_1277360;
struct_BoundaryMode_220129 _1277546;
_1277546.e0 = 0;
_1277546.e1 = _1277545;
if (_1277361) goto l1277362; else goto l1277599;
l1277599: ;
pbh_upper_1277365 = _1277546;
goto l1277363;
l1277362: ;
union variant_220130 _1265919_7017;
_1265919_7017.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7019;
_1265920_7019.e0 = 1;
_1265920_7019.e1 = _1265919_7017;
pbh_upper_1277365 = _1265920_7019;
goto l1277363;
l1277363: ;
bh_upper_1277365 = pbh_upper_1277365;
int _1277366;
_1277366 = _1277348 * _1277351;
int gid_y_1277367;
gid_y_1277367 = _1277345 + _1277366;
bool _1277368;
_1277368 = gid_y_1277367 < 0;
union variant_220130 _1277557;
_1277557.qs32 = gid_y_1277367;
struct_BoundaryMode_220129 _1277558;
_1277558.e0 = 0;
_1277558.e1 = _1277557;
if (_1277368) goto l1277369; else goto l1277598;
l1277598: ;
pbh_lower_1277372 = _1277558;
goto l1277370;
l1277369: ;
union variant_220130 _1265919_7027;
_1265919_7027.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7029;
_1265920_7029.e0 = 1;
_1265920_7029.e1 = _1265919_7027;
pbh_lower_1277372 = _1265920_7029;
goto l1277370;
l1277370: ;
bh_lower_1277372 = pbh_lower_1277372;
union variant_220130 _1277379;
_1277379 = bh_lower_1277372.e1;
unsigned int _1277373;
_1277373 = bh_upper_1277365.e0;
union variant_220130 _1277383;
_1277383 = bh_upper_1277365.e1;
unsigned int _1277375;
_1277375 = bh_lower_1277372.e0;
bool _1277376;
_1277376 = _1277375 == 0;
bool _1277374;
_1277374 = _1277373 == 0;
int _1277381;
_1277381 = _1035900_1277331.e3;
bool _1277377;
_1277377 = _1277374 & _1277376;
if (_1277377) goto l1277378; else goto l1277589;
l1277589: ;
bool _1277590;
_1277590 = _1277373 == 1;
if (_1277590) goto l1277591; else goto l1277593;
l1277593: ;
bool _1277594;
_1277594 = _1277375 == 1;
if (_1277594) goto l1277595; else goto l1277597;
l1277597: ;
// bottom: float r4_1265918_7042;
// bottom: p_1277392 = r4_1265918_7042;
goto l1277390;
l1277595: ;
float c_1277596;
c_1277596 = _1277379.pf32;
p_1277392 = c_1277596;
goto l1277390;
l1277591: ;
float c_1277592;
c_1277592 = _1277383.pf32;
p_1277392 = c_1277592;
goto l1277390;
l1277378: ;
int y_1277380;
y_1277380 = _1277379.qs32;
int _1277382;
_1277382 = y_1277380 * _1277381;
int x_1277384;
x_1277384 = _1277383.qs32;
int _1277385;
_1277385 = _1277382 + x_1277384;
float* idx_1277386;
idx_1277386 = _1035899_1277330 + _1277385;
_1277389 = __ldg(idx_1277386);
p_1277389 = _1277389;
l1277387: ;
_1277389 = p_1277389;
p_1277392 = _1277389;
goto l1277390;
l1277390: ;
_1277392 = p_1277392;
int _1277514;
_1277514 = _1035898_1277329.e3;
int _1277515;
_1277515 = gid_y_1277367 * _1277514;
int _1277516;
_1277516 = _1277515 + gid_x_1277360;
float* idx_1277517;
idx_1277517 = _1035902_1277333 + _1277516;
float _1277518;
_1277518 = *idx_1277517;
if (_1277361) goto l1277393; else goto l1277588;
l1277588: ;
pbh_upper_1277396 = _1277546;
goto l1277394;
l1277393: ;
union variant_220130 _1265919_7044;
_1265919_7044.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7046;
_1265920_7046.e0 = 1;
_1265920_7046.e1 = _1265919_7044;
pbh_upper_1277396 = _1265920_7046;
goto l1277394;
l1277394: ;
bh_upper_1277396 = pbh_upper_1277396;
int _1277397;
_1277397 = -1 + gid_y_1277367;
bool _1277398;
_1277398 = _1277397 < 0;
if (_1277398) goto l1277399; else goto l1277584;
l1277584: ;
union variant_220130 _1277585;
_1277585.qs32 = _1277397;
struct_BoundaryMode_220129 _1277586;
_1277586.e0 = 0;
_1277586.e1 = _1277585;
pbh_lower_1277402 = _1277586;
goto l1277400;
l1277399: ;
union variant_220130 _1265919_7055;
_1265919_7055.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7057;
_1265920_7057.e0 = 1;
_1265920_7057.e1 = _1265919_7055;
pbh_lower_1277402 = _1265920_7057;
goto l1277400;
l1277400: ;
bh_lower_1277402 = pbh_lower_1277402;
union variant_220130 _1277409;
_1277409 = bh_lower_1277402.e1;
unsigned int _1277403;
_1277403 = bh_upper_1277396.e0;
union variant_220130 _1277412;
_1277412 = bh_upper_1277396.e1;
unsigned int _1277405;
_1277405 = bh_lower_1277402.e0;
bool _1277404;
_1277404 = _1277403 == 0;
bool _1277406;
_1277406 = _1277405 == 0;
bool _1277407;
_1277407 = _1277404 & _1277406;
if (_1277407) goto l1277408; else goto l1277575;
l1277575: ;
bool _1277576;
_1277576 = _1277403 == 1;
if (_1277576) goto l1277577; else goto l1277579;
l1277579: ;
bool _1277580;
_1277580 = _1277405 == 1;
if (_1277580) goto l1277581; else goto l1277583;
l1277583: ;
// bottom: float r4_1265918_7069;
// bottom: p_1277421 = r4_1265918_7069;
goto l1277419;
l1277581: ;
float c_1277582;
c_1277582 = _1277409.pf32;
p_1277421 = c_1277582;
goto l1277419;
l1277577: ;
float c_1277578;
c_1277578 = _1277412.pf32;
p_1277421 = c_1277578;
goto l1277419;
l1277408: ;
int x_1277413;
x_1277413 = _1277412.qs32;
int y_1277410;
y_1277410 = _1277409.qs32;
int _1277411;
_1277411 = y_1277410 * _1277381;
int _1277414;
_1277414 = _1277411 + x_1277413;
float* idx_1277415;
idx_1277415 = _1035899_1277330 + _1277414;
_1277418 = __ldg(idx_1277415);
p_1277418 = _1277418;
l1277416: ;
_1277418 = p_1277418;
p_1277421 = _1277418;
goto l1277419;
l1277419: ;
_1277421 = p_1277421;
int _1277422;
_1277422 = -1 + gid_x_1277360;
bool _1277423;
_1277423 = _1277355 <= _1277422;
if (_1277423) goto l1277424; else goto l1277572;
l1277572: ;
union variant_220130 _1277573;
_1277573.qs32 = _1277422;
struct_BoundaryMode_220129 _1277574;
_1277574.e0 = 0;
_1277574.e1 = _1277573;
pbh_upper_1277427 = _1277574;
goto l1277425;
l1277424: ;
union variant_220130 _1265919_7074;
_1265919_7074.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7076;
_1265920_7076.e0 = 1;
_1265920_7076.e1 = _1265919_7074;
pbh_upper_1277427 = _1265920_7076;
goto l1277425;
l1277425: ;
bh_upper_1277427 = pbh_upper_1277427;
if (_1277368) goto l1277428; else goto l1277571;
l1277571: ;
pbh_lower_1277431 = _1277558;
goto l1277429;
l1277428: ;
union variant_220130 _1265919_7080;
_1265919_7080.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7082;
_1265920_7082.e0 = 1;
_1265920_7082.e1 = _1265919_7080;
pbh_lower_1277431 = _1265920_7082;
goto l1277429;
l1277429: ;
bh_lower_1277431 = pbh_lower_1277431;
union variant_220130 _1277441;
_1277441 = bh_upper_1277427.e1;
union variant_220130 _1277438;
_1277438 = bh_lower_1277431.e1;
unsigned int _1277434;
_1277434 = bh_lower_1277431.e0;
unsigned int _1277432;
_1277432 = bh_upper_1277427.e0;
bool _1277435;
_1277435 = _1277434 == 0;
bool _1277433;
_1277433 = _1277432 == 0;
bool _1277436;
_1277436 = _1277433 & _1277435;
if (_1277436) goto l1277437; else goto l1277562;
l1277562: ;
bool _1277563;
_1277563 = _1277432 == 1;
if (_1277563) goto l1277564; else goto l1277566;
l1277566: ;
bool _1277567;
_1277567 = _1277434 == 1;
if (_1277567) goto l1277568; else goto l1277570;
l1277570: ;
// bottom: float r4_1265918_7094;
// bottom: p_1277450 = r4_1265918_7094;
goto l1277448;
l1277568: ;
float c_1277569;
c_1277569 = _1277438.pf32;
p_1277450 = c_1277569;
goto l1277448;
l1277564: ;
float c_1277565;
c_1277565 = _1277441.pf32;
p_1277450 = c_1277565;
goto l1277448;
l1277437: ;
int y_1277439;
y_1277439 = _1277438.qs32;
int x_1277442;
x_1277442 = _1277441.qs32;
int _1277440;
_1277440 = y_1277439 * _1277381;
int _1277443;
_1277443 = _1277440 + x_1277442;
float* idx_1277444;
idx_1277444 = _1035899_1277330 + _1277443;
_1277447 = __ldg(idx_1277444);
p_1277447 = _1277447;
l1277445: ;
_1277447 = p_1277447;
p_1277450 = _1277447;
goto l1277448;
l1277448: ;
_1277450 = p_1277450;
int _1277451;
_1277451 = 1 + gid_x_1277360;
bool _1277452;
_1277452 = _1277355 <= _1277451;
if (_1277452) goto l1277453; else goto l1277559;
l1277559: ;
union variant_220130 _1277560;
_1277560.qs32 = _1277451;
struct_BoundaryMode_220129 _1277561;
_1277561.e0 = 0;
_1277561.e1 = _1277560;
pbh_upper_1277456 = _1277561;
goto l1277454;
l1277453: ;
union variant_220130 _1265919_7099;
_1265919_7099.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7101;
_1265920_7101.e0 = 1;
_1265920_7101.e1 = _1265919_7099;
pbh_upper_1277456 = _1265920_7101;
goto l1277454;
l1277454: ;
bh_upper_1277456 = pbh_upper_1277456;
if (_1277368) goto l1277457; else goto l1277556;
l1277556: ;
pbh_lower_1277460 = _1277558;
goto l1277458;
l1277457: ;
union variant_220130 _1265919_7105;
_1265919_7105.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7107;
_1265920_7107.e0 = 1;
_1265920_7107.e1 = _1265919_7105;
pbh_lower_1277460 = _1265920_7107;
goto l1277458;
l1277458: ;
bh_lower_1277460 = pbh_lower_1277460;
unsigned int _1277461;
_1277461 = bh_upper_1277456.e0;
union variant_220130 _1277470;
_1277470 = bh_upper_1277456.e1;
unsigned int _1277463;
_1277463 = bh_lower_1277460.e0;
bool _1277462;
_1277462 = _1277461 == 0;
union variant_220130 _1277467;
_1277467 = bh_lower_1277460.e1;
bool _1277464;
_1277464 = _1277463 == 0;
bool _1277465;
_1277465 = _1277462 & _1277464;
if (_1277465) goto l1277466; else goto l1277547;
l1277547: ;
bool _1277548;
_1277548 = _1277461 == 1;
if (_1277548) goto l1277549; else goto l1277551;
l1277551: ;
bool _1277552;
_1277552 = _1277463 == 1;
if (_1277552) goto l1277553; else goto l1277555;
l1277555: ;
// bottom: float r4_1265918_7119;
// bottom: p_1277479 = r4_1265918_7119;
goto l1277477;
l1277553: ;
float c_1277554;
c_1277554 = _1277467.pf32;
p_1277479 = c_1277554;
goto l1277477;
l1277549: ;
float c_1277550;
c_1277550 = _1277470.pf32;
p_1277479 = c_1277550;
goto l1277477;
l1277466: ;
int y_1277468;
y_1277468 = _1277467.qs32;
int _1277469;
_1277469 = y_1277468 * _1277381;
int x_1277471;
x_1277471 = _1277470.qs32;
int _1277472;
_1277472 = _1277469 + x_1277471;
float* idx_1277473;
idx_1277473 = _1035899_1277330 + _1277472;
_1277476 = __ldg(idx_1277473);
p_1277476 = _1277476;
l1277474: ;
_1277476 = p_1277476;
p_1277479 = _1277476;
goto l1277477;
l1277477: ;
_1277479 = p_1277479;
if (_1277361) goto l1277480; else goto l1277544;
l1277544: ;
pbh_upper_1277483 = _1277546;
goto l1277481;
l1277480: ;
union variant_220130 _1265919_7120;
_1265919_7120.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7122;
_1265920_7122.e0 = 1;
_1265920_7122.e1 = _1265919_7120;
pbh_upper_1277483 = _1265920_7122;
goto l1277481;
l1277481: ;
bh_upper_1277483 = pbh_upper_1277483;
int _1277484;
_1277484 = 1 + gid_y_1277367;
bool _1277485;
_1277485 = _1277484 < 0;
if (_1277485) goto l1277486; else goto l1277541;
l1277541: ;
union variant_220130 _1277542;
_1277542.qs32 = _1277484;
struct_BoundaryMode_220129 _1277543;
_1277543.e0 = 0;
_1277543.e1 = _1277542;
pbh_lower_1277489 = _1277543;
goto l1277487;
l1277486: ;
union variant_220130 _1265919_7131;
_1265919_7131.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7133;
_1265920_7133.e0 = 1;
_1265920_7133.e1 = _1265919_7131;
pbh_lower_1277489 = _1265920_7133;
goto l1277487;
l1277487: ;
bh_lower_1277489 = pbh_lower_1277489;
unsigned int _1277492;
_1277492 = bh_lower_1277489.e0;
unsigned int _1277490;
_1277490 = bh_upper_1277483.e0;
bool _1277493;
_1277493 = _1277492 == 0;
bool _1277491;
_1277491 = _1277490 == 0;
union variant_220130 _1277499;
_1277499 = bh_upper_1277483.e1;
union variant_220130 _1277496;
_1277496 = bh_lower_1277489.e1;
bool _1277494;
_1277494 = _1277491 & _1277493;
if (_1277494) goto l1277495; else goto l1277532;
l1277532: ;
bool _1277533;
_1277533 = _1277490 == 1;
if (_1277533) goto l1277534; else goto l1277536;
l1277536: ;
bool _1277537;
_1277537 = _1277492 == 1;
if (_1277537) goto l1277538; else goto l1277540;
l1277540: ;
// bottom: float r4_1265918_7145;
// bottom: p_1277508 = r4_1265918_7145;
goto l1277506;
l1277538: ;
float c_1277539;
c_1277539 = _1277496.pf32;
p_1277508 = c_1277539;
goto l1277506;
l1277534: ;
float c_1277535;
c_1277535 = _1277499.pf32;
p_1277508 = c_1277535;
goto l1277506;
l1277495: ;
int x_1277500;
x_1277500 = _1277499.qs32;
int y_1277497;
y_1277497 = _1277496.qs32;
int _1277498;
_1277498 = y_1277497 * _1277381;
int _1277501;
_1277501 = _1277498 + x_1277500;
float* idx_1277502;
idx_1277502 = _1035899_1277330 + _1277501;
_1277505 = __ldg(idx_1277502);
p_1277505 = _1277505;
l1277503: ;
_1277505 = p_1277505;
p_1277508 = _1277505;
goto l1277506;
l1277506: ;
_1277508 = p_1277508;
float _1277524;
_1277524 = 2.500000e-01f * _1277450;
float _1277513;
_1277513 = 2.000000e-01f * _1277392;
float _1277522;
_1277522 = 2.500000e-01f * _1277421;
int _1277509;
_1277509 = _1035901_1277332.e3;
float _1277528;
_1277528 = 2.500000e-01f * _1277508;
float _1277526;
_1277526 = 2.500000e-01f * _1277479;
float _1277519;
_1277519 = _1277518;
float _1277523;
_1277523 = 0.000000e+00f + _1277522;
float _1277525;
_1277525 = _1277523 + _1277524;
int _1277510;
_1277510 = gid_y_1277367 * _1277509;
float _1277520;
_1277520 = 2.000000e-01f * _1277519;
float _1277521;
_1277521 = _1277513 + _1277520;
float _1277527;
_1277527 = _1277525 + _1277526;
int _1277511;
_1277511 = _1277510 + gid_x_1277360;
float _1277529;
_1277529 = _1277527 + _1277528;
float* idx_1277512;
idx_1277512 = _1035897_1277328 + _1277511;
float val_1277530;
val_1277530 = _1277521 + _1277529;
*idx_1277512 = val_1277530;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1046131(float* _1046134_1286519, struct_Img_220118 _1046135_1286520, struct_Img_220118 _1046136_1286521, float* _1046137_1286522, struct_Img_220118 _1046138_1286523, float* _1046139_1286524) {
int _1286527;
int p_1286527;
int _1286530;
int p_1286530;
int _1286533;
int p_1286533;
int _1286536;
int p_1286536;
int _1286539;
int p_1286539;
int _1286542;
int p_1286542;
int _1286545;
int p_1286545;
struct_BoundaryMode_220129 bh_upper_1286556;
struct_BoundaryMode_220129 pbh_upper_1286556;
struct_BoundaryMode_220129 bh_upper_1286567;
struct_BoundaryMode_220129 pbh_upper_1286567;
float _1286584;
float p_1286584;
float _1286587;
float p_1286587;
struct_BoundaryMode_220129 bh_upper_1286591;
struct_BoundaryMode_220129 pbh_upper_1286591;
struct_BoundaryMode_220129 bh_upper_1286597;
struct_BoundaryMode_220129 pbh_upper_1286597;
float _1286613;
float p_1286613;
float _1286616;
float p_1286616;
struct_BoundaryMode_220129 bh_upper_1286622;
struct_BoundaryMode_220129 pbh_upper_1286622;
struct_BoundaryMode_220129 bh_upper_1286626;
struct_BoundaryMode_220129 pbh_upper_1286626;
float _1286642;
float p_1286642;
float _1286645;
float p_1286645;
struct_BoundaryMode_220129 bh_upper_1286651;
struct_BoundaryMode_220129 pbh_upper_1286651;
struct_BoundaryMode_220129 bh_upper_1286655;
struct_BoundaryMode_220129 pbh_upper_1286655;
float _1286671;
float p_1286671;
float _1286674;
float p_1286674;
struct_BoundaryMode_220129 bh_upper_1286678;
struct_BoundaryMode_220129 pbh_upper_1286678;
struct_BoundaryMode_220129 bh_upper_1286684;
struct_BoundaryMode_220129 pbh_upper_1286684;
float _1286700;
float p_1286700;
float _1286703;
float p_1286703;
_1286527 = threadIdx_x();
p_1286527 = _1286527;
l1286525: ;
_1286527 = p_1286527;
_1286530 = blockDim_x();
p_1286530 = _1286530;
l1286528: ;
_1286530 = p_1286530;
_1286533 = blockIdx_x();
p_1286533 = _1286533;
l1286531: ;
_1286533 = p_1286533;
_1286536 = threadIdx_y();
p_1286536 = _1286536;
l1286534: ;
_1286536 = p_1286536;
_1286539 = blockDim_y();
p_1286539 = _1286539;
l1286537: ;
_1286539 = p_1286539;
_1286542 = blockIdx_y();
p_1286542 = _1286542;
l1286540: ;
_1286542 = p_1286542;
_1286545 = blockDim_y();
p_1286545 = _1286545;
l1286543: ;
_1286545 = p_1286545;
int _1286547;
_1286547 = _1046138_1286523.e1;
int _1286548;
_1286548 = _1286547 - 128;
int _1286550;
_1286550 = _1286530 * _1286533;
int _1286549;
_1286549 = _1286548 + _1286527;
int _1286546;
_1286546 = _1046135_1286520.e1;
int gid_x_1286551;
gid_x_1286551 = _1286549 + _1286550;
bool _1286552;
_1286552 = _1286546 <= gid_x_1286551;
union variant_220130 _1286740;
_1286740.qs32 = gid_x_1286551;
struct_BoundaryMode_220129 _1286741;
_1286741.e0 = 0;
_1286741.e1 = _1286740;
if (_1286552) goto l1286553; else goto l1286794;
l1286794: ;
pbh_upper_1286556 = _1286741;
goto l1286554;
l1286553: ;
union variant_220130 _1265919_7160;
_1265919_7160.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7162;
_1265920_7162.e0 = 1;
_1265920_7162.e1 = _1265919_7160;
pbh_upper_1286556 = _1265920_7162;
goto l1286554;
l1286554: ;
bh_upper_1286556 = pbh_upper_1286556;
int _1286557;
_1286557 = _1046135_1286520.e2;
int _1286561;
_1286561 = _1286539 * _1286542;
int _1286558;
_1286558 = _1046138_1286523.e2;
int _1286559;
_1286559 = _1286558 - 1;
int _1286560;
_1286560 = _1286559 + _1286536;
int gid_y_1286562;
gid_y_1286562 = _1286560 + _1286561;
bool _1286563;
_1286563 = _1286557 <= gid_y_1286562;
union variant_220130 _1286752;
_1286752.qs32 = gid_y_1286562;
struct_BoundaryMode_220129 _1286753;
_1286753.e0 = 0;
_1286753.e1 = _1286752;
if (_1286563) goto l1286564; else goto l1286793;
l1286793: ;
pbh_upper_1286567 = _1286753;
goto l1286565;
l1286564: ;
union variant_220130 _1265919_7172;
_1265919_7172.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7174;
_1265920_7174.e0 = 1;
_1265920_7174.e1 = _1265919_7172;
pbh_upper_1286567 = _1265920_7174;
goto l1286565;
l1286565: ;
bh_upper_1286567 = pbh_upper_1286567;
unsigned int _1286570;
_1286570 = bh_upper_1286567.e0;
unsigned int _1286568;
_1286568 = bh_upper_1286556.e0;
int _1286576;
_1286576 = _1046135_1286520.e3;
bool _1286571;
_1286571 = _1286570 == 0;
bool _1286569;
_1286569 = _1286568 == 0;
union variant_220130 _1286574;
_1286574 = bh_upper_1286567.e1;
union variant_220130 _1286578;
_1286578 = bh_upper_1286556.e1;
bool _1286572;
_1286572 = _1286569 & _1286571;
if (_1286572) goto l1286573; else goto l1286784;
l1286784: ;
bool _1286785;
_1286785 = _1286568 == 1;
if (_1286785) goto l1286786; else goto l1286788;
l1286788: ;
bool _1286789;
_1286789 = _1286570 == 1;
if (_1286789) goto l1286790; else goto l1286792;
l1286792: ;
// bottom: float r4_1265918_7187;
// bottom: p_1286587 = r4_1265918_7187;
goto l1286585;
l1286790: ;
float c_1286791;
c_1286791 = _1286574.pf32;
p_1286587 = c_1286791;
goto l1286585;
l1286786: ;
float c_1286787;
c_1286787 = _1286578.pf32;
p_1286587 = c_1286787;
goto l1286585;
l1286573: ;
int x_1286579;
x_1286579 = _1286578.qs32;
int y_1286575;
y_1286575 = _1286574.qs32;
int _1286577;
_1286577 = y_1286575 * _1286576;
int _1286580;
_1286580 = _1286577 + x_1286579;
float* idx_1286581;
idx_1286581 = _1046134_1286519 + _1286580;
_1286584 = __ldg(idx_1286581);
p_1286584 = _1286584;
l1286582: ;
_1286584 = p_1286584;
p_1286587 = _1286584;
goto l1286585;
l1286585: ;
_1286587 = p_1286587;
int _1286709;
_1286709 = _1046136_1286521.e3;
int _1286710;
_1286710 = gid_y_1286562 * _1286709;
int _1286711;
_1286711 = _1286710 + gid_x_1286551;
float* idx_1286712;
idx_1286712 = _1046139_1286524 + _1286711;
float _1286713;
_1286713 = *idx_1286712;
if (_1286552) goto l1286588; else goto l1286783;
l1286783: ;
pbh_upper_1286591 = _1286741;
goto l1286589;
l1286588: ;
union variant_220130 _1265919_7189;
_1265919_7189.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7191;
_1265920_7191.e0 = 1;
_1265920_7191.e1 = _1265919_7189;
pbh_upper_1286591 = _1265920_7191;
goto l1286589;
l1286589: ;
bh_upper_1286591 = pbh_upper_1286591;
int _1286592;
_1286592 = -1 + gid_y_1286562;
bool _1286593;
_1286593 = _1286557 <= _1286592;
if (_1286593) goto l1286594; else goto l1286779;
l1286779: ;
union variant_220130 _1286780;
_1286780.qs32 = _1286592;
struct_BoundaryMode_220129 _1286781;
_1286781.e0 = 0;
_1286781.e1 = _1286780;
pbh_upper_1286597 = _1286781;
goto l1286595;
l1286594: ;
union variant_220130 _1265919_7199;
_1265919_7199.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7201;
_1265920_7201.e0 = 1;
_1265920_7201.e1 = _1265919_7199;
pbh_upper_1286597 = _1265920_7201;
goto l1286595;
l1286595: ;
bh_upper_1286597 = pbh_upper_1286597;
union variant_220130 _1286607;
_1286607 = bh_upper_1286591.e1;
unsigned int _1286600;
_1286600 = bh_upper_1286597.e0;
bool _1286601;
_1286601 = _1286600 == 0;
union variant_220130 _1286604;
_1286604 = bh_upper_1286597.e1;
unsigned int _1286598;
_1286598 = bh_upper_1286591.e0;
bool _1286599;
_1286599 = _1286598 == 0;
bool _1286602;
_1286602 = _1286599 & _1286601;
if (_1286602) goto l1286603; else goto l1286770;
l1286770: ;
bool _1286771;
_1286771 = _1286598 == 1;
if (_1286771) goto l1286772; else goto l1286774;
l1286774: ;
bool _1286775;
_1286775 = _1286600 == 1;
if (_1286775) goto l1286776; else goto l1286778;
l1286778: ;
// bottom: float r4_1265918_7213;
// bottom: p_1286616 = r4_1265918_7213;
goto l1286614;
l1286776: ;
float c_1286777;
c_1286777 = _1286604.pf32;
p_1286616 = c_1286777;
goto l1286614;
l1286772: ;
float c_1286773;
c_1286773 = _1286607.pf32;
p_1286616 = c_1286773;
goto l1286614;
l1286603: ;
int y_1286605;
y_1286605 = _1286604.qs32;
int x_1286608;
x_1286608 = _1286607.qs32;
int _1286606;
_1286606 = y_1286605 * _1286576;
int _1286609;
_1286609 = _1286606 + x_1286608;
float* idx_1286610;
idx_1286610 = _1046134_1286519 + _1286609;
_1286613 = __ldg(idx_1286610);
p_1286613 = _1286613;
l1286611: ;
_1286613 = p_1286613;
p_1286616 = _1286613;
goto l1286614;
l1286614: ;
_1286616 = p_1286616;
int _1286617;
_1286617 = -1 + gid_x_1286551;
bool _1286618;
_1286618 = _1286546 <= _1286617;
if (_1286618) goto l1286619; else goto l1286767;
l1286767: ;
union variant_220130 _1286768;
_1286768.qs32 = _1286617;
struct_BoundaryMode_220129 _1286769;
_1286769.e0 = 0;
_1286769.e1 = _1286768;
pbh_upper_1286622 = _1286769;
goto l1286620;
l1286619: ;
union variant_220130 _1265919_7218;
_1265919_7218.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7220;
_1265920_7220.e0 = 1;
_1265920_7220.e1 = _1265919_7218;
pbh_upper_1286622 = _1265920_7220;
goto l1286620;
l1286620: ;
bh_upper_1286622 = pbh_upper_1286622;
if (_1286563) goto l1286623; else goto l1286766;
l1286766: ;
pbh_upper_1286626 = _1286753;
goto l1286624;
l1286623: ;
union variant_220130 _1265919_7224;
_1265919_7224.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7226;
_1265920_7226.e0 = 1;
_1265920_7226.e1 = _1265919_7224;
pbh_upper_1286626 = _1265920_7226;
goto l1286624;
l1286624: ;
bh_upper_1286626 = pbh_upper_1286626;
union variant_220130 _1286636;
_1286636 = bh_upper_1286622.e1;
union variant_220130 _1286633;
_1286633 = bh_upper_1286626.e1;
unsigned int _1286629;
_1286629 = bh_upper_1286626.e0;
bool _1286630;
_1286630 = _1286629 == 0;
unsigned int _1286627;
_1286627 = bh_upper_1286622.e0;
bool _1286628;
_1286628 = _1286627 == 0;
bool _1286631;
_1286631 = _1286628 & _1286630;
if (_1286631) goto l1286632; else goto l1286757;
l1286757: ;
bool _1286758;
_1286758 = _1286627 == 1;
if (_1286758) goto l1286759; else goto l1286761;
l1286761: ;
bool _1286762;
_1286762 = _1286629 == 1;
if (_1286762) goto l1286763; else goto l1286765;
l1286765: ;
// bottom: float r4_1265918_7238;
// bottom: p_1286645 = r4_1265918_7238;
goto l1286643;
l1286763: ;
float c_1286764;
c_1286764 = _1286633.pf32;
p_1286645 = c_1286764;
goto l1286643;
l1286759: ;
float c_1286760;
c_1286760 = _1286636.pf32;
p_1286645 = c_1286760;
goto l1286643;
l1286632: ;
int x_1286637;
x_1286637 = _1286636.qs32;
int y_1286634;
y_1286634 = _1286633.qs32;
int _1286635;
_1286635 = y_1286634 * _1286576;
int _1286638;
_1286638 = _1286635 + x_1286637;
float* idx_1286639;
idx_1286639 = _1046134_1286519 + _1286638;
_1286642 = __ldg(idx_1286639);
p_1286642 = _1286642;
l1286640: ;
_1286642 = p_1286642;
p_1286645 = _1286642;
goto l1286643;
l1286643: ;
_1286645 = p_1286645;
int _1286646;
_1286646 = 1 + gid_x_1286551;
bool _1286647;
_1286647 = _1286546 <= _1286646;
if (_1286647) goto l1286648; else goto l1286754;
l1286754: ;
union variant_220130 _1286755;
_1286755.qs32 = _1286646;
struct_BoundaryMode_220129 _1286756;
_1286756.e0 = 0;
_1286756.e1 = _1286755;
pbh_upper_1286651 = _1286756;
goto l1286649;
l1286648: ;
union variant_220130 _1265919_7243;
_1265919_7243.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7245;
_1265920_7245.e0 = 1;
_1265920_7245.e1 = _1265919_7243;
pbh_upper_1286651 = _1265920_7245;
goto l1286649;
l1286649: ;
bh_upper_1286651 = pbh_upper_1286651;
if (_1286563) goto l1286652; else goto l1286751;
l1286751: ;
pbh_upper_1286655 = _1286753;
goto l1286653;
l1286652: ;
union variant_220130 _1265919_7249;
_1265919_7249.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7251;
_1265920_7251.e0 = 1;
_1265920_7251.e1 = _1265919_7249;
pbh_upper_1286655 = _1265920_7251;
goto l1286653;
l1286653: ;
bh_upper_1286655 = pbh_upper_1286655;
union variant_220130 _1286662;
_1286662 = bh_upper_1286655.e1;
union variant_220130 _1286665;
_1286665 = bh_upper_1286651.e1;
unsigned int _1286658;
_1286658 = bh_upper_1286655.e0;
unsigned int _1286656;
_1286656 = bh_upper_1286651.e0;
bool _1286659;
_1286659 = _1286658 == 0;
bool _1286657;
_1286657 = _1286656 == 0;
bool _1286660;
_1286660 = _1286657 & _1286659;
if (_1286660) goto l1286661; else goto l1286742;
l1286742: ;
bool _1286743;
_1286743 = _1286656 == 1;
if (_1286743) goto l1286744; else goto l1286746;
l1286746: ;
bool _1286747;
_1286747 = _1286658 == 1;
if (_1286747) goto l1286748; else goto l1286750;
l1286750: ;
// bottom: float r4_1265918_7263;
// bottom: p_1286674 = r4_1265918_7263;
goto l1286672;
l1286748: ;
float c_1286749;
c_1286749 = _1286662.pf32;
p_1286674 = c_1286749;
goto l1286672;
l1286744: ;
float c_1286745;
c_1286745 = _1286665.pf32;
p_1286674 = c_1286745;
goto l1286672;
l1286661: ;
int y_1286663;
y_1286663 = _1286662.qs32;
int _1286664;
_1286664 = y_1286663 * _1286576;
int x_1286666;
x_1286666 = _1286665.qs32;
int _1286667;
_1286667 = _1286664 + x_1286666;
float* idx_1286668;
idx_1286668 = _1046134_1286519 + _1286667;
_1286671 = __ldg(idx_1286668);
p_1286671 = _1286671;
l1286669: ;
_1286671 = p_1286671;
p_1286674 = _1286671;
goto l1286672;
l1286672: ;
_1286674 = p_1286674;
if (_1286552) goto l1286675; else goto l1286739;
l1286739: ;
pbh_upper_1286678 = _1286741;
goto l1286676;
l1286675: ;
union variant_220130 _1265919_7264;
_1265919_7264.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7266;
_1265920_7266.e0 = 1;
_1265920_7266.e1 = _1265919_7264;
pbh_upper_1286678 = _1265920_7266;
goto l1286676;
l1286676: ;
bh_upper_1286678 = pbh_upper_1286678;
int _1286679;
_1286679 = 1 + gid_y_1286562;
bool _1286680;
_1286680 = _1286557 <= _1286679;
if (_1286680) goto l1286681; else goto l1286736;
l1286736: ;
union variant_220130 _1286737;
_1286737.qs32 = _1286679;
struct_BoundaryMode_220129 _1286738;
_1286738.e0 = 0;
_1286738.e1 = _1286737;
pbh_upper_1286684 = _1286738;
goto l1286682;
l1286681: ;
union variant_220130 _1265919_7274;
_1265919_7274.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7276;
_1265920_7276.e0 = 1;
_1265920_7276.e1 = _1265919_7274;
pbh_upper_1286684 = _1265920_7276;
goto l1286682;
l1286682: ;
bh_upper_1286684 = pbh_upper_1286684;
union variant_220130 _1286691;
_1286691 = bh_upper_1286684.e1;
union variant_220130 _1286694;
_1286694 = bh_upper_1286678.e1;
unsigned int _1286685;
_1286685 = bh_upper_1286678.e0;
bool _1286686;
_1286686 = _1286685 == 0;
unsigned int _1286687;
_1286687 = bh_upper_1286684.e0;
bool _1286688;
_1286688 = _1286687 == 0;
bool _1286689;
_1286689 = _1286686 & _1286688;
if (_1286689) goto l1286690; else goto l1286727;
l1286727: ;
bool _1286728;
_1286728 = _1286685 == 1;
if (_1286728) goto l1286729; else goto l1286731;
l1286731: ;
bool _1286732;
_1286732 = _1286687 == 1;
if (_1286732) goto l1286733; else goto l1286735;
l1286735: ;
// bottom: float r4_1265918_7288;
// bottom: p_1286703 = r4_1265918_7288;
goto l1286701;
l1286733: ;
float c_1286734;
c_1286734 = _1286691.pf32;
p_1286703 = c_1286734;
goto l1286701;
l1286729: ;
float c_1286730;
c_1286730 = _1286694.pf32;
p_1286703 = c_1286730;
goto l1286701;
l1286690: ;
int x_1286695;
x_1286695 = _1286694.qs32;
int y_1286692;
y_1286692 = _1286691.qs32;
int _1286693;
_1286693 = y_1286692 * _1286576;
int _1286696;
_1286696 = _1286693 + x_1286695;
float* idx_1286697;
idx_1286697 = _1046134_1286519 + _1286696;
_1286700 = __ldg(idx_1286697);
p_1286700 = _1286700;
l1286698: ;
_1286700 = p_1286700;
p_1286703 = _1286700;
goto l1286701;
l1286701: ;
_1286703 = p_1286703;
float _1286708;
_1286708 = 2.000000e-01f * _1286587;
float _1286721;
_1286721 = 2.500000e-01f * _1286674;
int _1286704;
_1286704 = _1046138_1286523.e3;
float _1286714;
_1286714 = _1286713;
float _1286719;
_1286719 = 2.500000e-01f * _1286645;
int _1286705;
_1286705 = gid_y_1286562 * _1286704;
float _1286723;
_1286723 = 2.500000e-01f * _1286703;
float _1286717;
_1286717 = 2.500000e-01f * _1286616;
float _1286715;
_1286715 = 2.000000e-01f * _1286714;
int _1286706;
_1286706 = _1286705 + gid_x_1286551;
float _1286718;
_1286718 = 0.000000e+00f + _1286717;
float _1286716;
_1286716 = _1286708 + _1286715;
float* idx_1286707;
idx_1286707 = _1046137_1286522 + _1286706;
float _1286720;
_1286720 = _1286718 + _1286719;
float _1286722;
_1286722 = _1286720 + _1286721;
float _1286724;
_1286724 = _1286722 + _1286723;
float val_1286725;
val_1286725 = _1286716 + _1286724;
*idx_1286707 = val_1286725;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1010158(struct_Img_220118 _1010161_1283314, struct_Img_220118 _1010162_1283315, float* _1010163_1283316, struct_Img_220118 _1010164_1283317, float* _1010165_1283318, float* _1010166_1283319) {
int _1283322;
int p_1283322;
int _1283325;
int p_1283325;
int _1283328;
int p_1283328;
int _1283331;
int p_1283331;
int _1283334;
int p_1283334;
int _1283337;
int p_1283337;
int _1283340;
int p_1283340;
struct_BoundaryMode_220129 bh_lower_1283347;
struct_BoundaryMode_220129 pbh_lower_1283347;
float _1283362;
float p_1283362;
float _1283365;
float p_1283365;
struct_BoundaryMode_220129 bh_lower_1283369;
struct_BoundaryMode_220129 pbh_lower_1283369;
float _1283380;
float p_1283380;
float _1283383;
float p_1283383;
struct_BoundaryMode_220129 bh_lower_1283389;
struct_BoundaryMode_220129 pbh_lower_1283389;
float _1283399;
float p_1283399;
float _1283402;
float p_1283402;
struct_BoundaryMode_220129 bh_lower_1283408;
struct_BoundaryMode_220129 pbh_lower_1283408;
float _1283418;
float p_1283418;
float _1283421;
float p_1283421;
struct_BoundaryMode_220129 bh_lower_1283425;
struct_BoundaryMode_220129 pbh_lower_1283425;
float _1283437;
float p_1283437;
float _1283440;
float p_1283440;
_1283322 = threadIdx_x();
p_1283322 = _1283322;
l1283320: ;
_1283322 = p_1283322;
_1283325 = blockDim_x();
p_1283325 = _1283325;
l1283323: ;
_1283325 = p_1283325;
_1283328 = blockIdx_x();
p_1283328 = _1283328;
l1283326: ;
_1283328 = p_1283328;
_1283331 = threadIdx_y();
p_1283331 = _1283331;
l1283329: ;
_1283331 = p_1283331;
_1283334 = blockDim_y();
p_1283334 = _1283334;
l1283332: ;
_1283334 = p_1283334;
_1283337 = blockIdx_y();
p_1283337 = _1283337;
l1283335: ;
_1283337 = p_1283337;
_1283340 = blockDim_y();
p_1283340 = _1283340;
l1283338: ;
_1283340 = p_1283340;
int _1283341;
_1283341 = _1283325 * _1283328;
int gid_x_1283342;
gid_x_1283342 = _1283322 + _1283341;
union variant_220130 _1283470;
_1283470.qs32 = gid_x_1283342;
bool _1283343;
_1283343 = gid_x_1283342 < 0;
struct_BoundaryMode_220129 _1283471;
_1283471.e0 = 0;
_1283471.e1 = _1283470;
if (_1283343) goto l1283344; else goto l1283500;
l1283500: ;
pbh_lower_1283347 = _1283471;
goto l1283345;
l1283344: ;
union variant_220130 _1265919_7301;
_1265919_7301.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7303;
_1265920_7303.e0 = 1;
_1265920_7303.e1 = _1265919_7301;
pbh_lower_1283347 = _1265920_7303;
goto l1283345;
l1283345: ;
bh_lower_1283347 = pbh_lower_1283347;
int _1283351;
_1283351 = _1283334 * _1283337;
union variant_220130 _1283356;
_1283356 = bh_lower_1283347.e1;
int _1283354;
_1283354 = _1010161_1283314.e3;
unsigned int _1283348;
_1283348 = bh_lower_1283347.e0;
int gid_y_1283352;
gid_y_1283352 = _1283331 + _1283351;
bool _1283349;
_1283349 = _1283348 == 0;
int _1283353;
_1283353 = 1 + gid_y_1283352;
int _1283355;
_1283355 = _1283353 * _1283354;
if (_1283349) goto l1283350; else goto l1283495;
l1283495: ;
bool _1283496;
_1283496 = _1283348 == 1;
if (_1283496) goto l1283497; else goto l1283499;
l1283499: ;
// bottom: float r4_1265918_7313;
// bottom: p_1283365 = r4_1265918_7313;
goto l1283363;
l1283497: ;
float c_1283498;
c_1283498 = _1283356.pf32;
p_1283365 = c_1283498;
goto l1283363;
l1283350: ;
int x_1283357;
x_1283357 = _1283356.qs32;
int _1283358;
_1283358 = _1283355 + x_1283357;
float* idx_1283359;
idx_1283359 = _1010165_1283318 + _1283358;
_1283362 = __ldg(idx_1283359);
p_1283362 = _1283362;
l1283360: ;
_1283362 = p_1283362;
p_1283365 = _1283362;
goto l1283363;
l1283363: ;
_1283365 = p_1283365;
int _1283446;
_1283446 = _1010162_1283315.e3;
int _1283447;
_1283447 = _1283353 * _1283446;
int _1283448;
_1283448 = _1283447 + gid_x_1283342;
float* idx_1283449;
idx_1283449 = _1010166_1283319 + _1283448;
float _1283450;
_1283450 = *idx_1283449;
if (_1283343) goto l1283366; else goto l1283494;
l1283494: ;
pbh_lower_1283369 = _1283471;
goto l1283367;
l1283366: ;
union variant_220130 _1265919_7315;
_1265919_7315.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7317;
_1265920_7317.e0 = 1;
_1265920_7317.e1 = _1265919_7315;
pbh_lower_1283369 = _1265920_7317;
goto l1283367;
l1283367: ;
bh_lower_1283369 = pbh_lower_1283369;
union variant_220130 _1283374;
_1283374 = bh_lower_1283369.e1;
unsigned int _1283370;
_1283370 = bh_lower_1283369.e0;
bool _1283371;
_1283371 = _1283370 == 0;
if (_1283371) goto l1283372; else goto l1283488;
l1283488: ;
bool _1283489;
_1283489 = _1283370 == 1;
if (_1283489) goto l1283490; else goto l1283492;
l1283492: ;
// bottom: float r4_1265918_7325;
// bottom: p_1283383 = r4_1265918_7325;
goto l1283381;
l1283490: ;
float c_1283491;
c_1283491 = _1283374.pf32;
p_1283383 = c_1283491;
goto l1283381;
l1283372: ;
int _1283373;
_1283373 = gid_y_1283352 * _1283354;
int x_1283375;
x_1283375 = _1283374.qs32;
int _1283376;
_1283376 = _1283373 + x_1283375;
float* idx_1283377;
idx_1283377 = _1010165_1283318 + _1283376;
_1283380 = __ldg(idx_1283377);
p_1283380 = _1283380;
l1283378: ;
_1283380 = p_1283380;
p_1283383 = _1283380;
goto l1283381;
l1283381: ;
_1283383 = p_1283383;
int _1283384;
_1283384 = -1 + gid_x_1283342;
bool _1283385;
_1283385 = _1283384 < 0;
if (_1283385) goto l1283386; else goto l1283485;
l1283485: ;
union variant_220130 _1283486;
_1283486.qs32 = _1283384;
struct_BoundaryMode_220129 _1283487;
_1283487.e0 = 0;
_1283487.e1 = _1283486;
pbh_lower_1283389 = _1283487;
goto l1283387;
l1283386: ;
union variant_220130 _1265919_7331;
_1265919_7331.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7333;
_1265920_7333.e0 = 1;
_1265920_7333.e1 = _1265919_7331;
pbh_lower_1283389 = _1265920_7333;
goto l1283387;
l1283387: ;
bh_lower_1283389 = pbh_lower_1283389;
union variant_220130 _1283393;
_1283393 = bh_lower_1283389.e1;
unsigned int _1283390;
_1283390 = bh_lower_1283389.e0;
bool _1283391;
_1283391 = _1283390 == 0;
if (_1283391) goto l1283392; else goto l1283480;
l1283480: ;
bool _1283481;
_1283481 = _1283390 == 1;
if (_1283481) goto l1283482; else goto l1283484;
l1283484: ;
// bottom: float r4_1265918_7341;
// bottom: p_1283402 = r4_1265918_7341;
goto l1283400;
l1283482: ;
float c_1283483;
c_1283483 = _1283393.pf32;
p_1283402 = c_1283483;
goto l1283400;
l1283392: ;
int x_1283394;
x_1283394 = _1283393.qs32;
int _1283395;
_1283395 = _1283355 + x_1283394;
float* idx_1283396;
idx_1283396 = _1010165_1283318 + _1283395;
_1283399 = __ldg(idx_1283396);
p_1283399 = _1283399;
l1283397: ;
_1283399 = p_1283399;
p_1283402 = _1283399;
goto l1283400;
l1283400: ;
_1283402 = p_1283402;
int _1283403;
_1283403 = 1 + gid_x_1283342;
bool _1283404;
_1283404 = _1283403 < 0;
if (_1283404) goto l1283405; else goto l1283477;
l1283477: ;
union variant_220130 _1283478;
_1283478.qs32 = _1283403;
struct_BoundaryMode_220129 _1283479;
_1283479.e0 = 0;
_1283479.e1 = _1283478;
pbh_lower_1283408 = _1283479;
goto l1283406;
l1283405: ;
union variant_220130 _1265919_7347;
_1265919_7347.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7349;
_1265920_7349.e0 = 1;
_1265920_7349.e1 = _1265919_7347;
pbh_lower_1283408 = _1265920_7349;
goto l1283406;
l1283406: ;
bh_lower_1283408 = pbh_lower_1283408;
unsigned int _1283409;
_1283409 = bh_lower_1283408.e0;
union variant_220130 _1283412;
_1283412 = bh_lower_1283408.e1;
bool _1283410;
_1283410 = _1283409 == 0;
if (_1283410) goto l1283411; else goto l1283472;
l1283472: ;
bool _1283473;
_1283473 = _1283409 == 1;
if (_1283473) goto l1283474; else goto l1283476;
l1283476: ;
// bottom: float r4_1265918_7357;
// bottom: p_1283421 = r4_1265918_7357;
goto l1283419;
l1283474: ;
float c_1283475;
c_1283475 = _1283412.pf32;
p_1283421 = c_1283475;
goto l1283419;
l1283411: ;
int x_1283413;
x_1283413 = _1283412.qs32;
int _1283414;
_1283414 = _1283355 + x_1283413;
float* idx_1283415;
idx_1283415 = _1010165_1283318 + _1283414;
_1283418 = __ldg(idx_1283415);
p_1283418 = _1283418;
l1283416: ;
_1283418 = p_1283418;
p_1283421 = _1283418;
goto l1283419;
l1283419: ;
_1283421 = p_1283421;
if (_1283343) goto l1283422; else goto l1283469;
l1283469: ;
pbh_lower_1283425 = _1283471;
goto l1283423;
l1283422: ;
union variant_220130 _1265919_7358;
_1265919_7358.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7360;
_1265920_7360.e0 = 1;
_1265920_7360.e1 = _1265919_7358;
pbh_lower_1283425 = _1265920_7360;
goto l1283423;
l1283423: ;
bh_lower_1283425 = pbh_lower_1283425;
unsigned int _1283426;
_1283426 = bh_lower_1283425.e0;
union variant_220130 _1283431;
_1283431 = bh_lower_1283425.e1;
bool _1283427;
_1283427 = _1283426 == 0;
if (_1283427) goto l1283428; else goto l1283464;
l1283464: ;
bool _1283465;
_1283465 = _1283426 == 1;
if (_1283465) goto l1283466; else goto l1283468;
l1283468: ;
// bottom: float r4_1265918_7368;
// bottom: p_1283440 = r4_1265918_7368;
goto l1283438;
l1283466: ;
float c_1283467;
c_1283467 = _1283431.pf32;
p_1283440 = c_1283467;
goto l1283438;
l1283428: ;
int x_1283432;
x_1283432 = _1283431.qs32;
int _1283429;
_1283429 = 2 + gid_y_1283352;
int _1283430;
_1283430 = _1283429 * _1283354;
int _1283433;
_1283433 = _1283430 + x_1283432;
float* idx_1283434;
idx_1283434 = _1010165_1283318 + _1283433;
_1283437 = __ldg(idx_1283434);
p_1283437 = _1283437;
l1283435: ;
_1283437 = p_1283437;
p_1283440 = _1283437;
goto l1283438;
l1283438: ;
_1283440 = p_1283440;
float _1283458;
_1283458 = 2.500000e-01f * _1283421;
float _1283454;
_1283454 = 2.500000e-01f * _1283383;
float _1283460;
_1283460 = 2.500000e-01f * _1283440;
float _1283445;
_1283445 = 2.000000e-01f * _1283365;
float _1283455;
_1283455 = 0.000000e+00f + _1283454;
float _1283456;
_1283456 = 2.500000e-01f * _1283402;
float _1283451;
_1283451 = _1283450;
int _1283441;
_1283441 = _1010164_1283317.e3;
int _1283442;
_1283442 = _1283353 * _1283441;
float _1283457;
_1283457 = _1283455 + _1283456;
float _1283452;
_1283452 = 2.000000e-01f * _1283451;
int _1283443;
_1283443 = _1283442 + gid_x_1283342;
float _1283459;
_1283459 = _1283457 + _1283458;
float _1283453;
_1283453 = _1283445 + _1283452;
float* idx_1283444;
idx_1283444 = _1010163_1283316 + _1283443;
float _1283461;
_1283461 = _1283459 + _1283460;
float val_1283462;
val_1283462 = _1283453 + _1283461;
*idx_1283444 = val_1283462;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1042281(float* _1042284_1272390, struct_Img_220118 _1042285_1272391, struct_Img_220118 _1042286_1272392, float* _1042287_1272393, struct_Img_220118 _1042288_1272394, float* _1042289_1272395) {
int _1272398;
int p_1272398;
int _1272401;
int p_1272401;
int _1272404;
int p_1272404;
int _1272407;
int p_1272407;
int _1272410;
int p_1272410;
int _1272413;
int p_1272413;
int _1272416;
int p_1272416;
struct_BoundaryMode_220129 bh_lower_1272423;
struct_BoundaryMode_220129 pbh_lower_1272423;
struct_BoundaryMode_220129 bh_lower_1272430;
struct_BoundaryMode_220129 pbh_lower_1272430;
float _1272447;
float p_1272447;
float _1272450;
float p_1272450;
struct_BoundaryMode_220129 bh_lower_1272454;
struct_BoundaryMode_220129 pbh_lower_1272454;
struct_BoundaryMode_220129 bh_lower_1272460;
struct_BoundaryMode_220129 pbh_lower_1272460;
float _1272476;
float p_1272476;
float _1272479;
float p_1272479;
struct_BoundaryMode_220129 bh_lower_1272485;
struct_BoundaryMode_220129 pbh_lower_1272485;
struct_BoundaryMode_220129 bh_lower_1272489;
struct_BoundaryMode_220129 pbh_lower_1272489;
float _1272505;
float p_1272505;
float _1272508;
float p_1272508;
struct_BoundaryMode_220129 bh_lower_1272514;
struct_BoundaryMode_220129 pbh_lower_1272514;
struct_BoundaryMode_220129 bh_lower_1272518;
struct_BoundaryMode_220129 pbh_lower_1272518;
float _1272534;
float p_1272534;
float _1272537;
float p_1272537;
struct_BoundaryMode_220129 bh_lower_1272541;
struct_BoundaryMode_220129 pbh_lower_1272541;
struct_BoundaryMode_220129 bh_lower_1272547;
struct_BoundaryMode_220129 pbh_lower_1272547;
float _1272563;
float p_1272563;
float _1272566;
float p_1272566;
_1272398 = threadIdx_x();
p_1272398 = _1272398;
l1272396: ;
_1272398 = p_1272398;
_1272401 = blockDim_x();
p_1272401 = _1272401;
l1272399: ;
_1272401 = p_1272401;
_1272404 = blockIdx_x();
p_1272404 = _1272404;
l1272402: ;
_1272404 = p_1272404;
_1272407 = threadIdx_y();
p_1272407 = _1272407;
l1272405: ;
_1272407 = p_1272407;
_1272410 = blockDim_y();
p_1272410 = _1272410;
l1272408: ;
_1272410 = p_1272410;
_1272413 = blockIdx_y();
p_1272413 = _1272413;
l1272411: ;
_1272413 = p_1272413;
_1272416 = blockDim_y();
p_1272416 = _1272416;
l1272414: ;
_1272416 = p_1272416;
int _1272417;
_1272417 = _1272401 * _1272404;
int gid_x_1272418;
gid_x_1272418 = _1272398 + _1272417;
bool _1272419;
_1272419 = gid_x_1272418 < 0;
union variant_220130 _1272603;
_1272603.qs32 = gid_x_1272418;
struct_BoundaryMode_220129 _1272604;
_1272604.e0 = 0;
_1272604.e1 = _1272603;
if (_1272419) goto l1272420; else goto l1272657;
l1272657: ;
pbh_lower_1272423 = _1272604;
goto l1272421;
l1272420: ;
union variant_220130 _1265919_7382;
_1265919_7382.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7384;
_1265920_7384.e0 = 1;
_1265920_7384.e1 = _1265919_7382;
pbh_lower_1272423 = _1265920_7384;
goto l1272421;
l1272421: ;
bh_lower_1272423 = pbh_lower_1272423;
int _1272424;
_1272424 = _1272410 * _1272413;
int gid_y_1272425;
gid_y_1272425 = _1272407 + _1272424;
bool _1272426;
_1272426 = gid_y_1272425 < 0;
union variant_220130 _1272615;
_1272615.qs32 = gid_y_1272425;
struct_BoundaryMode_220129 _1272616;
_1272616.e0 = 0;
_1272616.e1 = _1272615;
if (_1272426) goto l1272427; else goto l1272656;
l1272656: ;
pbh_lower_1272430 = _1272616;
goto l1272428;
l1272427: ;
union variant_220130 _1265919_7392;
_1265919_7392.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7394;
_1265920_7394.e0 = 1;
_1265920_7394.e1 = _1265919_7392;
pbh_lower_1272430 = _1265920_7394;
goto l1272428;
l1272428: ;
bh_lower_1272430 = pbh_lower_1272430;
union variant_220130 _1272441;
_1272441 = bh_lower_1272423.e1;
unsigned int _1272431;
_1272431 = bh_lower_1272423.e0;
bool _1272432;
_1272432 = _1272431 == 0;
int _1272439;
_1272439 = _1042285_1272391.e3;
union variant_220130 _1272437;
_1272437 = bh_lower_1272430.e1;
unsigned int _1272433;
_1272433 = bh_lower_1272430.e0;
bool _1272434;
_1272434 = _1272433 == 0;
bool _1272435;
_1272435 = _1272432 & _1272434;
if (_1272435) goto l1272436; else goto l1272647;
l1272647: ;
bool _1272648;
_1272648 = _1272431 == 1;
if (_1272648) goto l1272649; else goto l1272651;
l1272651: ;
bool _1272652;
_1272652 = _1272433 == 1;
if (_1272652) goto l1272653; else goto l1272655;
l1272655: ;
// bottom: float r4_1265918_7407;
// bottom: p_1272450 = r4_1265918_7407;
goto l1272448;
l1272653: ;
float c_1272654;
c_1272654 = _1272437.pf32;
p_1272450 = c_1272654;
goto l1272448;
l1272649: ;
float c_1272650;
c_1272650 = _1272441.pf32;
p_1272450 = c_1272650;
goto l1272448;
l1272436: ;
int y_1272438;
y_1272438 = _1272437.qs32;
int _1272440;
_1272440 = y_1272438 * _1272439;
int x_1272442;
x_1272442 = _1272441.qs32;
int _1272443;
_1272443 = _1272440 + x_1272442;
float* idx_1272444;
idx_1272444 = _1042284_1272390 + _1272443;
_1272447 = __ldg(idx_1272444);
p_1272447 = _1272447;
l1272445: ;
_1272447 = p_1272447;
p_1272450 = _1272447;
goto l1272448;
l1272448: ;
_1272450 = p_1272450;
int _1272572;
_1272572 = _1042286_1272392.e3;
int _1272573;
_1272573 = gid_y_1272425 * _1272572;
int _1272574;
_1272574 = _1272573 + gid_x_1272418;
float* idx_1272575;
idx_1272575 = _1042289_1272395 + _1272574;
float _1272576;
_1272576 = *idx_1272575;
if (_1272419) goto l1272451; else goto l1272646;
l1272646: ;
pbh_lower_1272454 = _1272604;
goto l1272452;
l1272451: ;
union variant_220130 _1265919_7409;
_1265919_7409.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7411;
_1265920_7411.e0 = 1;
_1265920_7411.e1 = _1265919_7409;
pbh_lower_1272454 = _1265920_7411;
goto l1272452;
l1272452: ;
bh_lower_1272454 = pbh_lower_1272454;
int _1272455;
_1272455 = -1 + gid_y_1272425;
bool _1272456;
_1272456 = _1272455 < 0;
if (_1272456) goto l1272457; else goto l1272642;
l1272642: ;
union variant_220130 _1272643;
_1272643.qs32 = _1272455;
struct_BoundaryMode_220129 _1272644;
_1272644.e0 = 0;
_1272644.e1 = _1272643;
pbh_lower_1272460 = _1272644;
goto l1272458;
l1272457: ;
union variant_220130 _1265919_7420;
_1265919_7420.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7422;
_1265920_7422.e0 = 1;
_1265920_7422.e1 = _1265919_7420;
pbh_lower_1272460 = _1265920_7422;
goto l1272458;
l1272458: ;
bh_lower_1272460 = pbh_lower_1272460;
union variant_220130 _1272467;
_1272467 = bh_lower_1272460.e1;
unsigned int _1272463;
_1272463 = bh_lower_1272460.e0;
bool _1272464;
_1272464 = _1272463 == 0;
union variant_220130 _1272470;
_1272470 = bh_lower_1272454.e1;
unsigned int _1272461;
_1272461 = bh_lower_1272454.e0;
bool _1272462;
_1272462 = _1272461 == 0;
bool _1272465;
_1272465 = _1272462 & _1272464;
if (_1272465) goto l1272466; else goto l1272633;
l1272633: ;
bool _1272634;
_1272634 = _1272461 == 1;
if (_1272634) goto l1272635; else goto l1272637;
l1272637: ;
bool _1272638;
_1272638 = _1272463 == 1;
if (_1272638) goto l1272639; else goto l1272641;
l1272641: ;
// bottom: float r4_1265918_7434;
// bottom: p_1272479 = r4_1265918_7434;
goto l1272477;
l1272639: ;
float c_1272640;
c_1272640 = _1272467.pf32;
p_1272479 = c_1272640;
goto l1272477;
l1272635: ;
float c_1272636;
c_1272636 = _1272470.pf32;
p_1272479 = c_1272636;
goto l1272477;
l1272466: ;
int y_1272468;
y_1272468 = _1272467.qs32;
int _1272469;
_1272469 = y_1272468 * _1272439;
int x_1272471;
x_1272471 = _1272470.qs32;
int _1272472;
_1272472 = _1272469 + x_1272471;
float* idx_1272473;
idx_1272473 = _1042284_1272390 + _1272472;
_1272476 = __ldg(idx_1272473);
p_1272476 = _1272476;
l1272474: ;
_1272476 = p_1272476;
p_1272479 = _1272476;
goto l1272477;
l1272477: ;
_1272479 = p_1272479;
int _1272480;
_1272480 = -1 + gid_x_1272418;
bool _1272481;
_1272481 = _1272480 < 0;
if (_1272481) goto l1272482; else goto l1272630;
l1272630: ;
union variant_220130 _1272631;
_1272631.qs32 = _1272480;
struct_BoundaryMode_220129 _1272632;
_1272632.e0 = 0;
_1272632.e1 = _1272631;
pbh_lower_1272485 = _1272632;
goto l1272483;
l1272482: ;
union variant_220130 _1265919_7440;
_1265919_7440.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7442;
_1265920_7442.e0 = 1;
_1265920_7442.e1 = _1265919_7440;
pbh_lower_1272485 = _1265920_7442;
goto l1272483;
l1272483: ;
bh_lower_1272485 = pbh_lower_1272485;
if (_1272426) goto l1272486; else goto l1272629;
l1272629: ;
pbh_lower_1272489 = _1272616;
goto l1272487;
l1272486: ;
union variant_220130 _1265919_7446;
_1265919_7446.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7448;
_1265920_7448.e0 = 1;
_1265920_7448.e1 = _1265919_7446;
pbh_lower_1272489 = _1265920_7448;
goto l1272487;
l1272487: ;
bh_lower_1272489 = pbh_lower_1272489;
unsigned int _1272490;
_1272490 = bh_lower_1272485.e0;
union variant_220130 _1272496;
_1272496 = bh_lower_1272489.e1;
unsigned int _1272492;
_1272492 = bh_lower_1272489.e0;
bool _1272491;
_1272491 = _1272490 == 0;
union variant_220130 _1272499;
_1272499 = bh_lower_1272485.e1;
bool _1272493;
_1272493 = _1272492 == 0;
bool _1272494;
_1272494 = _1272491 & _1272493;
if (_1272494) goto l1272495; else goto l1272620;
l1272620: ;
bool _1272621;
_1272621 = _1272490 == 1;
if (_1272621) goto l1272622; else goto l1272624;
l1272624: ;
bool _1272625;
_1272625 = _1272492 == 1;
if (_1272625) goto l1272626; else goto l1272628;
l1272628: ;
// bottom: float r4_1265918_7460;
// bottom: p_1272508 = r4_1265918_7460;
goto l1272506;
l1272626: ;
float c_1272627;
c_1272627 = _1272496.pf32;
p_1272508 = c_1272627;
goto l1272506;
l1272622: ;
float c_1272623;
c_1272623 = _1272499.pf32;
p_1272508 = c_1272623;
goto l1272506;
l1272495: ;
int x_1272500;
x_1272500 = _1272499.qs32;
int y_1272497;
y_1272497 = _1272496.qs32;
int _1272498;
_1272498 = y_1272497 * _1272439;
int _1272501;
_1272501 = _1272498 + x_1272500;
float* idx_1272502;
idx_1272502 = _1042284_1272390 + _1272501;
_1272505 = __ldg(idx_1272502);
p_1272505 = _1272505;
l1272503: ;
_1272505 = p_1272505;
p_1272508 = _1272505;
goto l1272506;
l1272506: ;
_1272508 = p_1272508;
int _1272509;
_1272509 = 1 + gid_x_1272418;
bool _1272510;
_1272510 = _1272509 < 0;
if (_1272510) goto l1272511; else goto l1272617;
l1272617: ;
union variant_220130 _1272618;
_1272618.qs32 = _1272509;
struct_BoundaryMode_220129 _1272619;
_1272619.e0 = 0;
_1272619.e1 = _1272618;
pbh_lower_1272514 = _1272619;
goto l1272512;
l1272511: ;
union variant_220130 _1265919_7466;
_1265919_7466.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7468;
_1265920_7468.e0 = 1;
_1265920_7468.e1 = _1265919_7466;
pbh_lower_1272514 = _1265920_7468;
goto l1272512;
l1272512: ;
bh_lower_1272514 = pbh_lower_1272514;
if (_1272426) goto l1272515; else goto l1272614;
l1272614: ;
pbh_lower_1272518 = _1272616;
goto l1272516;
l1272515: ;
union variant_220130 _1265919_7472;
_1265919_7472.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7474;
_1265920_7474.e0 = 1;
_1265920_7474.e1 = _1265919_7472;
pbh_lower_1272518 = _1265920_7474;
goto l1272516;
l1272516: ;
bh_lower_1272518 = pbh_lower_1272518;
unsigned int _1272521;
_1272521 = bh_lower_1272518.e0;
union variant_220130 _1272528;
_1272528 = bh_lower_1272514.e1;
unsigned int _1272519;
_1272519 = bh_lower_1272514.e0;
bool _1272520;
_1272520 = _1272519 == 0;
union variant_220130 _1272525;
_1272525 = bh_lower_1272518.e1;
bool _1272522;
_1272522 = _1272521 == 0;
bool _1272523;
_1272523 = _1272520 & _1272522;
if (_1272523) goto l1272524; else goto l1272605;
l1272605: ;
bool _1272606;
_1272606 = _1272519 == 1;
if (_1272606) goto l1272607; else goto l1272609;
l1272609: ;
bool _1272610;
_1272610 = _1272521 == 1;
if (_1272610) goto l1272611; else goto l1272613;
l1272613: ;
// bottom: float r4_1265918_7486;
// bottom: p_1272537 = r4_1265918_7486;
goto l1272535;
l1272611: ;
float c_1272612;
c_1272612 = _1272525.pf32;
p_1272537 = c_1272612;
goto l1272535;
l1272607: ;
float c_1272608;
c_1272608 = _1272528.pf32;
p_1272537 = c_1272608;
goto l1272535;
l1272524: ;
int x_1272529;
x_1272529 = _1272528.qs32;
int y_1272526;
y_1272526 = _1272525.qs32;
int _1272527;
_1272527 = y_1272526 * _1272439;
int _1272530;
_1272530 = _1272527 + x_1272529;
float* idx_1272531;
idx_1272531 = _1042284_1272390 + _1272530;
_1272534 = __ldg(idx_1272531);
p_1272534 = _1272534;
l1272532: ;
_1272534 = p_1272534;
p_1272537 = _1272534;
goto l1272535;
l1272535: ;
_1272537 = p_1272537;
if (_1272419) goto l1272538; else goto l1272602;
l1272602: ;
pbh_lower_1272541 = _1272604;
goto l1272539;
l1272538: ;
union variant_220130 _1265919_7487;
_1265919_7487.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7489;
_1265920_7489.e0 = 1;
_1265920_7489.e1 = _1265919_7487;
pbh_lower_1272541 = _1265920_7489;
goto l1272539;
l1272539: ;
bh_lower_1272541 = pbh_lower_1272541;
int _1272542;
_1272542 = 1 + gid_y_1272425;
bool _1272543;
_1272543 = _1272542 < 0;
if (_1272543) goto l1272544; else goto l1272599;
l1272599: ;
union variant_220130 _1272600;
_1272600.qs32 = _1272542;
struct_BoundaryMode_220129 _1272601;
_1272601.e0 = 0;
_1272601.e1 = _1272600;
pbh_lower_1272547 = _1272601;
goto l1272545;
l1272544: ;
union variant_220130 _1265919_7498;
_1265919_7498.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7500;
_1265920_7500.e0 = 1;
_1265920_7500.e1 = _1265919_7498;
pbh_lower_1272547 = _1265920_7500;
goto l1272545;
l1272545: ;
bh_lower_1272547 = pbh_lower_1272547;
unsigned int _1272548;
_1272548 = bh_lower_1272541.e0;
union variant_220130 _1272557;
_1272557 = bh_lower_1272541.e1;
unsigned int _1272550;
_1272550 = bh_lower_1272547.e0;
union variant_220130 _1272554;
_1272554 = bh_lower_1272547.e1;
bool _1272549;
_1272549 = _1272548 == 0;
bool _1272551;
_1272551 = _1272550 == 0;
bool _1272552;
_1272552 = _1272549 & _1272551;
if (_1272552) goto l1272553; else goto l1272590;
l1272590: ;
bool _1272591;
_1272591 = _1272548 == 1;
if (_1272591) goto l1272592; else goto l1272594;
l1272594: ;
bool _1272595;
_1272595 = _1272550 == 1;
if (_1272595) goto l1272596; else goto l1272598;
l1272598: ;
// bottom: float r4_1265918_7512;
// bottom: p_1272566 = r4_1265918_7512;
goto l1272564;
l1272596: ;
float c_1272597;
c_1272597 = _1272554.pf32;
p_1272566 = c_1272597;
goto l1272564;
l1272592: ;
float c_1272593;
c_1272593 = _1272557.pf32;
p_1272566 = c_1272593;
goto l1272564;
l1272553: ;
int y_1272555;
y_1272555 = _1272554.qs32;
int _1272556;
_1272556 = y_1272555 * _1272439;
int x_1272558;
x_1272558 = _1272557.qs32;
int _1272559;
_1272559 = _1272556 + x_1272558;
float* idx_1272560;
idx_1272560 = _1042284_1272390 + _1272559;
_1272563 = __ldg(idx_1272560);
p_1272563 = _1272563;
l1272561: ;
_1272563 = p_1272563;
p_1272566 = _1272563;
goto l1272564;
l1272564: ;
_1272566 = p_1272566;
float _1272580;
_1272580 = 2.500000e-01f * _1272479;
int _1272567;
_1272567 = _1042288_1272394.e3;
float _1272582;
_1272582 = 2.500000e-01f * _1272508;
float _1272581;
_1272581 = 0.000000e+00f + _1272580;
float _1272586;
_1272586 = 2.500000e-01f * _1272566;
float _1272584;
_1272584 = 2.500000e-01f * _1272537;
float _1272577;
_1272577 = _1272576;
float _1272578;
_1272578 = 2.000000e-01f * _1272577;
float _1272571;
_1272571 = 2.000000e-01f * _1272450;
int _1272568;
_1272568 = gid_y_1272425 * _1272567;
float _1272583;
_1272583 = _1272581 + _1272582;
float _1272585;
_1272585 = _1272583 + _1272584;
float _1272579;
_1272579 = _1272571 + _1272578;
int _1272569;
_1272569 = _1272568 + gid_x_1272418;
float _1272587;
_1272587 = _1272585 + _1272586;
float val_1272588;
val_1272588 = _1272579 + _1272587;
float* idx_1272570;
idx_1272570 = _1042287_1272393 + _1272569;
*idx_1272570 = val_1272588;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1042824(float* _1042827_1268869, struct_Img_220118 _1042828_1268870, struct_Img_220118 _1042829_1268871, float* _1042830_1268872, struct_Img_220118 _1042831_1268873, float* _1042832_1268874) {
int _1268877;
int p_1268877;
int _1268880;
int p_1268880;
int _1268883;
int p_1268883;
int _1268886;
int p_1268886;
int _1268889;
int p_1268889;
int _1268892;
int p_1268892;
int _1268895;
int p_1268895;
struct_BoundaryMode_220129 bh_lower_1268902;
struct_BoundaryMode_220129 pbh_lower_1268902;
float _1268917;
float p_1268917;
float _1268920;
float p_1268920;
struct_BoundaryMode_220129 bh_lower_1268924;
struct_BoundaryMode_220129 pbh_lower_1268924;
float _1268935;
float p_1268935;
float _1268938;
float p_1268938;
struct_BoundaryMode_220129 bh_lower_1268944;
struct_BoundaryMode_220129 pbh_lower_1268944;
float _1268954;
float p_1268954;
float _1268957;
float p_1268957;
struct_BoundaryMode_220129 bh_lower_1268963;
struct_BoundaryMode_220129 pbh_lower_1268963;
float _1268973;
float p_1268973;
float _1268976;
float p_1268976;
struct_BoundaryMode_220129 bh_lower_1268980;
struct_BoundaryMode_220129 pbh_lower_1268980;
float _1268992;
float p_1268992;
float _1268995;
float p_1268995;
_1268877 = threadIdx_x();
p_1268877 = _1268877;
l1268875: ;
_1268877 = p_1268877;
_1268880 = blockDim_x();
p_1268880 = _1268880;
l1268878: ;
_1268880 = p_1268880;
_1268883 = blockIdx_x();
p_1268883 = _1268883;
l1268881: ;
_1268883 = p_1268883;
_1268886 = threadIdx_y();
p_1268886 = _1268886;
l1268884: ;
_1268886 = p_1268886;
_1268889 = blockDim_y();
p_1268889 = _1268889;
l1268887: ;
_1268889 = p_1268889;
_1268892 = blockIdx_y();
p_1268892 = _1268892;
l1268890: ;
_1268892 = p_1268892;
_1268895 = blockDim_y();
p_1268895 = _1268895;
l1268893: ;
_1268895 = p_1268895;
int _1268896;
_1268896 = _1268880 * _1268883;
int gid_x_1268897;
gid_x_1268897 = _1268877 + _1268896;
union variant_220130 _1269025;
_1269025.qs32 = gid_x_1268897;
bool _1268898;
_1268898 = gid_x_1268897 < 0;
struct_BoundaryMode_220129 _1269026;
_1269026.e0 = 0;
_1269026.e1 = _1269025;
if (_1268898) goto l1268899; else goto l1269055;
l1269055: ;
pbh_lower_1268902 = _1269026;
goto l1268900;
l1268899: ;
union variant_220130 _1265919_7525;
_1265919_7525.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7527;
_1265920_7527.e0 = 1;
_1265920_7527.e1 = _1265919_7525;
pbh_lower_1268902 = _1265920_7527;
goto l1268900;
l1268900: ;
bh_lower_1268902 = pbh_lower_1268902;
unsigned int _1268903;
_1268903 = bh_lower_1268902.e0;
int _1268906;
_1268906 = _1268889 * _1268892;
int _1268909;
_1268909 = _1042828_1268870.e3;
union variant_220130 _1268911;
_1268911 = bh_lower_1268902.e1;
int gid_y_1268907;
gid_y_1268907 = _1268886 + _1268906;
bool _1268904;
_1268904 = _1268903 == 0;
int _1268908;
_1268908 = 1 + gid_y_1268907;
int _1268910;
_1268910 = _1268908 * _1268909;
if (_1268904) goto l1268905; else goto l1269050;
l1269050: ;
bool _1269051;
_1269051 = _1268903 == 1;
if (_1269051) goto l1269052; else goto l1269054;
l1269054: ;
// bottom: float r4_1265918_7537;
// bottom: p_1268920 = r4_1265918_7537;
goto l1268918;
l1269052: ;
float c_1269053;
c_1269053 = _1268911.pf32;
p_1268920 = c_1269053;
goto l1268918;
l1268905: ;
int x_1268912;
x_1268912 = _1268911.qs32;
int _1268913;
_1268913 = _1268910 + x_1268912;
float* idx_1268914;
idx_1268914 = _1042827_1268869 + _1268913;
_1268917 = __ldg(idx_1268914);
p_1268917 = _1268917;
l1268915: ;
_1268917 = p_1268917;
p_1268920 = _1268917;
goto l1268918;
l1268918: ;
_1268920 = p_1268920;
int _1269001;
_1269001 = _1042829_1268871.e3;
int _1269002;
_1269002 = _1268908 * _1269001;
int _1269003;
_1269003 = _1269002 + gid_x_1268897;
float* idx_1269004;
idx_1269004 = _1042832_1268874 + _1269003;
float _1269005;
_1269005 = *idx_1269004;
if (_1268898) goto l1268921; else goto l1269049;
l1269049: ;
pbh_lower_1268924 = _1269026;
goto l1268922;
l1268921: ;
union variant_220130 _1265919_7539;
_1265919_7539.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7541;
_1265920_7541.e0 = 1;
_1265920_7541.e1 = _1265919_7539;
pbh_lower_1268924 = _1265920_7541;
goto l1268922;
l1268922: ;
bh_lower_1268924 = pbh_lower_1268924;
union variant_220130 _1268929;
_1268929 = bh_lower_1268924.e1;
unsigned int _1268925;
_1268925 = bh_lower_1268924.e0;
bool _1268926;
_1268926 = _1268925 == 0;
if (_1268926) goto l1268927; else goto l1269043;
l1269043: ;
bool _1269044;
_1269044 = _1268925 == 1;
if (_1269044) goto l1269045; else goto l1269047;
l1269047: ;
// bottom: float r4_1265918_7549;
// bottom: p_1268938 = r4_1265918_7549;
goto l1268936;
l1269045: ;
float c_1269046;
c_1269046 = _1268929.pf32;
p_1268938 = c_1269046;
goto l1268936;
l1268927: ;
int x_1268930;
x_1268930 = _1268929.qs32;
int _1268928;
_1268928 = gid_y_1268907 * _1268909;
int _1268931;
_1268931 = _1268928 + x_1268930;
float* idx_1268932;
idx_1268932 = _1042827_1268869 + _1268931;
_1268935 = __ldg(idx_1268932);
p_1268935 = _1268935;
l1268933: ;
_1268935 = p_1268935;
p_1268938 = _1268935;
goto l1268936;
l1268936: ;
_1268938 = p_1268938;
int _1268939;
_1268939 = -1 + gid_x_1268897;
bool _1268940;
_1268940 = _1268939 < 0;
if (_1268940) goto l1268941; else goto l1269040;
l1269040: ;
union variant_220130 _1269041;
_1269041.qs32 = _1268939;
struct_BoundaryMode_220129 _1269042;
_1269042.e0 = 0;
_1269042.e1 = _1269041;
pbh_lower_1268944 = _1269042;
goto l1268942;
l1268941: ;
union variant_220130 _1265919_7555;
_1265919_7555.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7557;
_1265920_7557.e0 = 1;
_1265920_7557.e1 = _1265919_7555;
pbh_lower_1268944 = _1265920_7557;
goto l1268942;
l1268942: ;
bh_lower_1268944 = pbh_lower_1268944;
unsigned int _1268945;
_1268945 = bh_lower_1268944.e0;
union variant_220130 _1268948;
_1268948 = bh_lower_1268944.e1;
bool _1268946;
_1268946 = _1268945 == 0;
if (_1268946) goto l1268947; else goto l1269035;
l1269035: ;
bool _1269036;
_1269036 = _1268945 == 1;
if (_1269036) goto l1269037; else goto l1269039;
l1269039: ;
// bottom: float r4_1265918_7565;
// bottom: p_1268957 = r4_1265918_7565;
goto l1268955;
l1269037: ;
float c_1269038;
c_1269038 = _1268948.pf32;
p_1268957 = c_1269038;
goto l1268955;
l1268947: ;
int x_1268949;
x_1268949 = _1268948.qs32;
int _1268950;
_1268950 = _1268910 + x_1268949;
float* idx_1268951;
idx_1268951 = _1042827_1268869 + _1268950;
_1268954 = __ldg(idx_1268951);
p_1268954 = _1268954;
l1268952: ;
_1268954 = p_1268954;
p_1268957 = _1268954;
goto l1268955;
l1268955: ;
_1268957 = p_1268957;
int _1268958;
_1268958 = 1 + gid_x_1268897;
bool _1268959;
_1268959 = _1268958 < 0;
if (_1268959) goto l1268960; else goto l1269032;
l1269032: ;
union variant_220130 _1269033;
_1269033.qs32 = _1268958;
struct_BoundaryMode_220129 _1269034;
_1269034.e0 = 0;
_1269034.e1 = _1269033;
pbh_lower_1268963 = _1269034;
goto l1268961;
l1268960: ;
union variant_220130 _1265919_7571;
_1265919_7571.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7573;
_1265920_7573.e0 = 1;
_1265920_7573.e1 = _1265919_7571;
pbh_lower_1268963 = _1265920_7573;
goto l1268961;
l1268961: ;
bh_lower_1268963 = pbh_lower_1268963;
unsigned int _1268964;
_1268964 = bh_lower_1268963.e0;
union variant_220130 _1268967;
_1268967 = bh_lower_1268963.e1;
bool _1268965;
_1268965 = _1268964 == 0;
if (_1268965) goto l1268966; else goto l1269027;
l1269027: ;
bool _1269028;
_1269028 = _1268964 == 1;
if (_1269028) goto l1269029; else goto l1269031;
l1269031: ;
// bottom: float r4_1265918_7581;
// bottom: p_1268976 = r4_1265918_7581;
goto l1268974;
l1269029: ;
float c_1269030;
c_1269030 = _1268967.pf32;
p_1268976 = c_1269030;
goto l1268974;
l1268966: ;
int x_1268968;
x_1268968 = _1268967.qs32;
int _1268969;
_1268969 = _1268910 + x_1268968;
float* idx_1268970;
idx_1268970 = _1042827_1268869 + _1268969;
_1268973 = __ldg(idx_1268970);
p_1268973 = _1268973;
l1268971: ;
_1268973 = p_1268973;
p_1268976 = _1268973;
goto l1268974;
l1268974: ;
_1268976 = p_1268976;
if (_1268898) goto l1268977; else goto l1269024;
l1269024: ;
pbh_lower_1268980 = _1269026;
goto l1268978;
l1268977: ;
union variant_220130 _1265919_7582;
_1265919_7582.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7584;
_1265920_7584.e0 = 1;
_1265920_7584.e1 = _1265919_7582;
pbh_lower_1268980 = _1265920_7584;
goto l1268978;
l1268978: ;
bh_lower_1268980 = pbh_lower_1268980;
unsigned int _1268981;
_1268981 = bh_lower_1268980.e0;
bool _1268982;
_1268982 = _1268981 == 0;
union variant_220130 _1268986;
_1268986 = bh_lower_1268980.e1;
if (_1268982) goto l1268983; else goto l1269019;
l1269019: ;
bool _1269020;
_1269020 = _1268981 == 1;
if (_1269020) goto l1269021; else goto l1269023;
l1269023: ;
// bottom: float r4_1265918_7592;
// bottom: p_1268995 = r4_1265918_7592;
goto l1268993;
l1269021: ;
float c_1269022;
c_1269022 = _1268986.pf32;
p_1268995 = c_1269022;
goto l1268993;
l1268983: ;
int x_1268987;
x_1268987 = _1268986.qs32;
int _1268984;
_1268984 = 2 + gid_y_1268907;
int _1268985;
_1268985 = _1268984 * _1268909;
int _1268988;
_1268988 = _1268985 + x_1268987;
float* idx_1268989;
idx_1268989 = _1042827_1268869 + _1268988;
_1268992 = __ldg(idx_1268989);
p_1268992 = _1268992;
l1268990: ;
_1268992 = p_1268992;
p_1268995 = _1268992;
goto l1268993;
l1268993: ;
_1268995 = p_1268995;
float _1269015;
_1269015 = 2.500000e-01f * _1268995;
float _1269011;
_1269011 = 2.500000e-01f * _1268957;
float _1269006;
_1269006 = _1269005;
int _1268996;
_1268996 = _1042831_1268873.e3;
float _1269013;
_1269013 = 2.500000e-01f * _1268976;
float _1269009;
_1269009 = 2.500000e-01f * _1268938;
float _1269000;
_1269000 = 2.000000e-01f * _1268920;
float _1269010;
_1269010 = 0.000000e+00f + _1269009;
float _1269012;
_1269012 = _1269010 + _1269011;
float _1269007;
_1269007 = 2.000000e-01f * _1269006;
int _1268997;
_1268997 = _1268908 * _1268996;
float _1269014;
_1269014 = _1269012 + _1269013;
float _1269008;
_1269008 = _1269000 + _1269007;
int _1268998;
_1268998 = _1268997 + gid_x_1268897;
float _1269016;
_1269016 = _1269014 + _1269015;
float val_1269017;
val_1269017 = _1269008 + _1269016;
float* idx_1268999;
idx_1268999 = _1042830_1268872 + _1268998;
*idx_1268999 = val_1269017;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1013465(struct_Img_220118 _1013468_1276778, struct_Img_220118 _1013469_1276779, float* _1013470_1276780, struct_Img_220118 _1013471_1276781, float* _1013472_1276782, float* _1013473_1276783) {
int _1276786;
int p_1276786;
int _1276789;
int p_1276789;
int _1276792;
int p_1276792;
int _1276795;
int p_1276795;
int _1276798;
int p_1276798;
int _1276801;
int p_1276801;
int _1276804;
int p_1276804;
struct_BoundaryMode_220129 bh_upper_1276815;
struct_BoundaryMode_220129 pbh_upper_1276815;
struct_BoundaryMode_220129 bh_upper_1276826;
struct_BoundaryMode_220129 pbh_upper_1276826;
float _1276843;
float p_1276843;
float _1276846;
float p_1276846;
struct_BoundaryMode_220129 bh_upper_1276850;
struct_BoundaryMode_220129 pbh_upper_1276850;
struct_BoundaryMode_220129 bh_upper_1276856;
struct_BoundaryMode_220129 pbh_upper_1276856;
float _1276872;
float p_1276872;
float _1276875;
float p_1276875;
struct_BoundaryMode_220129 bh_upper_1276881;
struct_BoundaryMode_220129 pbh_upper_1276881;
struct_BoundaryMode_220129 bh_upper_1276885;
struct_BoundaryMode_220129 pbh_upper_1276885;
float _1276901;
float p_1276901;
float _1276904;
float p_1276904;
struct_BoundaryMode_220129 bh_upper_1276910;
struct_BoundaryMode_220129 pbh_upper_1276910;
struct_BoundaryMode_220129 bh_upper_1276914;
struct_BoundaryMode_220129 pbh_upper_1276914;
float _1276930;
float p_1276930;
float _1276933;
float p_1276933;
struct_BoundaryMode_220129 bh_upper_1276937;
struct_BoundaryMode_220129 pbh_upper_1276937;
struct_BoundaryMode_220129 bh_upper_1276943;
struct_BoundaryMode_220129 pbh_upper_1276943;
float _1276959;
float p_1276959;
float _1276962;
float p_1276962;
_1276786 = threadIdx_x();
p_1276786 = _1276786;
l1276784: ;
_1276786 = p_1276786;
_1276789 = blockDim_x();
p_1276789 = _1276789;
l1276787: ;
_1276789 = p_1276789;
_1276792 = blockIdx_x();
p_1276792 = _1276792;
l1276790: ;
_1276792 = p_1276792;
_1276795 = threadIdx_y();
p_1276795 = _1276795;
l1276793: ;
_1276795 = p_1276795;
_1276798 = blockDim_y();
p_1276798 = _1276798;
l1276796: ;
_1276798 = p_1276798;
_1276801 = blockIdx_y();
p_1276801 = _1276801;
l1276799: ;
_1276801 = p_1276801;
_1276804 = blockDim_y();
p_1276804 = _1276804;
l1276802: ;
_1276804 = p_1276804;
int _1276806;
_1276806 = _1013471_1276781.e1;
int _1276809;
_1276809 = _1276789 * _1276792;
int _1276807;
_1276807 = _1276806 - 128;
int _1276808;
_1276808 = _1276807 + _1276786;
int _1276805;
_1276805 = _1013468_1276778.e1;
int gid_x_1276810;
gid_x_1276810 = _1276808 + _1276809;
bool _1276811;
_1276811 = _1276805 <= gid_x_1276810;
union variant_220130 _1276999;
_1276999.qs32 = gid_x_1276810;
struct_BoundaryMode_220129 _1277000;
_1277000.e0 = 0;
_1277000.e1 = _1276999;
if (_1276811) goto l1276812; else goto l1277053;
l1277053: ;
pbh_upper_1276815 = _1277000;
goto l1276813;
l1276812: ;
union variant_220130 _1265919_7608;
_1265919_7608.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7610;
_1265920_7610.e0 = 1;
_1265920_7610.e1 = _1265919_7608;
pbh_upper_1276815 = _1265920_7610;
goto l1276813;
l1276813: ;
bh_upper_1276815 = pbh_upper_1276815;
int _1276816;
_1276816 = _1013468_1276778.e2;
int _1276820;
_1276820 = _1276798 * _1276801;
int _1276817;
_1276817 = _1013471_1276781.e2;
int _1276818;
_1276818 = _1276817 - 1;
int _1276819;
_1276819 = _1276818 + _1276795;
int gid_y_1276821;
gid_y_1276821 = _1276819 + _1276820;
bool _1276822;
_1276822 = _1276816 <= gid_y_1276821;
union variant_220130 _1277011;
_1277011.qs32 = gid_y_1276821;
struct_BoundaryMode_220129 _1277012;
_1277012.e0 = 0;
_1277012.e1 = _1277011;
if (_1276822) goto l1276823; else goto l1277052;
l1277052: ;
pbh_upper_1276826 = _1277012;
goto l1276824;
l1276823: ;
union variant_220130 _1265919_7620;
_1265919_7620.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7622;
_1265920_7622.e0 = 1;
_1265920_7622.e1 = _1265919_7620;
pbh_upper_1276826 = _1265920_7622;
goto l1276824;
l1276824: ;
bh_upper_1276826 = pbh_upper_1276826;
union variant_220130 _1276833;
_1276833 = bh_upper_1276826.e1;
int _1276835;
_1276835 = _1013468_1276778.e3;
union variant_220130 _1276837;
_1276837 = bh_upper_1276815.e1;
unsigned int _1276827;
_1276827 = bh_upper_1276815.e0;
unsigned int _1276829;
_1276829 = bh_upper_1276826.e0;
bool _1276828;
_1276828 = _1276827 == 0;
bool _1276830;
_1276830 = _1276829 == 0;
bool _1276831;
_1276831 = _1276828 & _1276830;
if (_1276831) goto l1276832; else goto l1277043;
l1277043: ;
bool _1277044;
_1277044 = _1276827 == 1;
if (_1277044) goto l1277045; else goto l1277047;
l1277047: ;
bool _1277048;
_1277048 = _1276829 == 1;
if (_1277048) goto l1277049; else goto l1277051;
l1277051: ;
// bottom: float r4_1265918_7635;
// bottom: p_1276846 = r4_1265918_7635;
goto l1276844;
l1277049: ;
float c_1277050;
c_1277050 = _1276833.pf32;
p_1276846 = c_1277050;
goto l1276844;
l1277045: ;
float c_1277046;
c_1277046 = _1276837.pf32;
p_1276846 = c_1277046;
goto l1276844;
l1276832: ;
int y_1276834;
y_1276834 = _1276833.qs32;
int x_1276838;
x_1276838 = _1276837.qs32;
int _1276836;
_1276836 = y_1276834 * _1276835;
int _1276839;
_1276839 = _1276836 + x_1276838;
float* idx_1276840;
idx_1276840 = _1013472_1276782 + _1276839;
_1276843 = __ldg(idx_1276840);
p_1276843 = _1276843;
l1276841: ;
_1276843 = p_1276843;
p_1276846 = _1276843;
goto l1276844;
l1276844: ;
_1276846 = p_1276846;
int _1276968;
_1276968 = _1013469_1276779.e3;
int _1276969;
_1276969 = gid_y_1276821 * _1276968;
int _1276970;
_1276970 = _1276969 + gid_x_1276810;
float* idx_1276971;
idx_1276971 = _1013473_1276783 + _1276970;
float _1276972;
_1276972 = *idx_1276971;
if (_1276811) goto l1276847; else goto l1277042;
l1277042: ;
pbh_upper_1276850 = _1277000;
goto l1276848;
l1276847: ;
union variant_220130 _1265919_7637;
_1265919_7637.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7639;
_1265920_7639.e0 = 1;
_1265920_7639.e1 = _1265919_7637;
pbh_upper_1276850 = _1265920_7639;
goto l1276848;
l1276848: ;
bh_upper_1276850 = pbh_upper_1276850;
int _1276851;
_1276851 = -1 + gid_y_1276821;
bool _1276852;
_1276852 = _1276816 <= _1276851;
if (_1276852) goto l1276853; else goto l1277038;
l1277038: ;
union variant_220130 _1277039;
_1277039.qs32 = _1276851;
struct_BoundaryMode_220129 _1277040;
_1277040.e0 = 0;
_1277040.e1 = _1277039;
pbh_upper_1276856 = _1277040;
goto l1276854;
l1276853: ;
union variant_220130 _1265919_7647;
_1265919_7647.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7649;
_1265920_7649.e0 = 1;
_1265920_7649.e1 = _1265919_7647;
pbh_upper_1276856 = _1265920_7649;
goto l1276854;
l1276854: ;
bh_upper_1276856 = pbh_upper_1276856;
union variant_220130 _1276863;
_1276863 = bh_upper_1276856.e1;
unsigned int _1276857;
_1276857 = bh_upper_1276850.e0;
unsigned int _1276859;
_1276859 = bh_upper_1276856.e0;
bool _1276858;
_1276858 = _1276857 == 0;
union variant_220130 _1276866;
_1276866 = bh_upper_1276850.e1;
bool _1276860;
_1276860 = _1276859 == 0;
bool _1276861;
_1276861 = _1276858 & _1276860;
if (_1276861) goto l1276862; else goto l1277029;
l1277029: ;
bool _1277030;
_1277030 = _1276857 == 1;
if (_1277030) goto l1277031; else goto l1277033;
l1277033: ;
bool _1277034;
_1277034 = _1276859 == 1;
if (_1277034) goto l1277035; else goto l1277037;
l1277037: ;
// bottom: float r4_1265918_7661;
// bottom: p_1276875 = r4_1265918_7661;
goto l1276873;
l1277035: ;
float c_1277036;
c_1277036 = _1276863.pf32;
p_1276875 = c_1277036;
goto l1276873;
l1277031: ;
float c_1277032;
c_1277032 = _1276866.pf32;
p_1276875 = c_1277032;
goto l1276873;
l1276862: ;
int x_1276867;
x_1276867 = _1276866.qs32;
int y_1276864;
y_1276864 = _1276863.qs32;
int _1276865;
_1276865 = y_1276864 * _1276835;
int _1276868;
_1276868 = _1276865 + x_1276867;
float* idx_1276869;
idx_1276869 = _1013472_1276782 + _1276868;
_1276872 = __ldg(idx_1276869);
p_1276872 = _1276872;
l1276870: ;
_1276872 = p_1276872;
p_1276875 = _1276872;
goto l1276873;
l1276873: ;
_1276875 = p_1276875;
int _1276876;
_1276876 = -1 + gid_x_1276810;
bool _1276877;
_1276877 = _1276805 <= _1276876;
if (_1276877) goto l1276878; else goto l1277026;
l1277026: ;
union variant_220130 _1277027;
_1277027.qs32 = _1276876;
struct_BoundaryMode_220129 _1277028;
_1277028.e0 = 0;
_1277028.e1 = _1277027;
pbh_upper_1276881 = _1277028;
goto l1276879;
l1276878: ;
union variant_220130 _1265919_7666;
_1265919_7666.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7668;
_1265920_7668.e0 = 1;
_1265920_7668.e1 = _1265919_7666;
pbh_upper_1276881 = _1265920_7668;
goto l1276879;
l1276879: ;
bh_upper_1276881 = pbh_upper_1276881;
if (_1276822) goto l1276882; else goto l1277025;
l1277025: ;
pbh_upper_1276885 = _1277012;
goto l1276883;
l1276882: ;
union variant_220130 _1265919_7672;
_1265919_7672.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7674;
_1265920_7674.e0 = 1;
_1265920_7674.e1 = _1265919_7672;
pbh_upper_1276885 = _1265920_7674;
goto l1276883;
l1276883: ;
bh_upper_1276885 = pbh_upper_1276885;
union variant_220130 _1276895;
_1276895 = bh_upper_1276881.e1;
union variant_220130 _1276892;
_1276892 = bh_upper_1276885.e1;
unsigned int _1276886;
_1276886 = bh_upper_1276881.e0;
unsigned int _1276888;
_1276888 = bh_upper_1276885.e0;
bool _1276887;
_1276887 = _1276886 == 0;
bool _1276889;
_1276889 = _1276888 == 0;
bool _1276890;
_1276890 = _1276887 & _1276889;
if (_1276890) goto l1276891; else goto l1277016;
l1277016: ;
bool _1277017;
_1277017 = _1276886 == 1;
if (_1277017) goto l1277018; else goto l1277020;
l1277020: ;
bool _1277021;
_1277021 = _1276888 == 1;
if (_1277021) goto l1277022; else goto l1277024;
l1277024: ;
// bottom: float r4_1265918_7686;
// bottom: p_1276904 = r4_1265918_7686;
goto l1276902;
l1277022: ;
float c_1277023;
c_1277023 = _1276892.pf32;
p_1276904 = c_1277023;
goto l1276902;
l1277018: ;
float c_1277019;
c_1277019 = _1276895.pf32;
p_1276904 = c_1277019;
goto l1276902;
l1276891: ;
int x_1276896;
x_1276896 = _1276895.qs32;
int y_1276893;
y_1276893 = _1276892.qs32;
int _1276894;
_1276894 = y_1276893 * _1276835;
int _1276897;
_1276897 = _1276894 + x_1276896;
float* idx_1276898;
idx_1276898 = _1013472_1276782 + _1276897;
_1276901 = __ldg(idx_1276898);
p_1276901 = _1276901;
l1276899: ;
_1276901 = p_1276901;
p_1276904 = _1276901;
goto l1276902;
l1276902: ;
_1276904 = p_1276904;
int _1276905;
_1276905 = 1 + gid_x_1276810;
bool _1276906;
_1276906 = _1276805 <= _1276905;
if (_1276906) goto l1276907; else goto l1277013;
l1277013: ;
union variant_220130 _1277014;
_1277014.qs32 = _1276905;
struct_BoundaryMode_220129 _1277015;
_1277015.e0 = 0;
_1277015.e1 = _1277014;
pbh_upper_1276910 = _1277015;
goto l1276908;
l1276907: ;
union variant_220130 _1265919_7691;
_1265919_7691.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7693;
_1265920_7693.e0 = 1;
_1265920_7693.e1 = _1265919_7691;
pbh_upper_1276910 = _1265920_7693;
goto l1276908;
l1276908: ;
bh_upper_1276910 = pbh_upper_1276910;
if (_1276822) goto l1276911; else goto l1277010;
l1277010: ;
pbh_upper_1276914 = _1277012;
goto l1276912;
l1276911: ;
union variant_220130 _1265919_7697;
_1265919_7697.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7699;
_1265920_7699.e0 = 1;
_1265920_7699.e1 = _1265919_7697;
pbh_upper_1276914 = _1265920_7699;
goto l1276912;
l1276912: ;
bh_upper_1276914 = pbh_upper_1276914;
unsigned int _1276915;
_1276915 = bh_upper_1276910.e0;
union variant_220130 _1276921;
_1276921 = bh_upper_1276914.e1;
union variant_220130 _1276924;
_1276924 = bh_upper_1276910.e1;
unsigned int _1276917;
_1276917 = bh_upper_1276914.e0;
bool _1276916;
_1276916 = _1276915 == 0;
bool _1276918;
_1276918 = _1276917 == 0;
bool _1276919;
_1276919 = _1276916 & _1276918;
if (_1276919) goto l1276920; else goto l1277001;
l1277001: ;
bool _1277002;
_1277002 = _1276915 == 1;
if (_1277002) goto l1277003; else goto l1277005;
l1277005: ;
bool _1277006;
_1277006 = _1276917 == 1;
if (_1277006) goto l1277007; else goto l1277009;
l1277009: ;
// bottom: float r4_1265918_7711;
// bottom: p_1276933 = r4_1265918_7711;
goto l1276931;
l1277007: ;
float c_1277008;
c_1277008 = _1276921.pf32;
p_1276933 = c_1277008;
goto l1276931;
l1277003: ;
float c_1277004;
c_1277004 = _1276924.pf32;
p_1276933 = c_1277004;
goto l1276931;
l1276920: ;
int x_1276925;
x_1276925 = _1276924.qs32;
int y_1276922;
y_1276922 = _1276921.qs32;
int _1276923;
_1276923 = y_1276922 * _1276835;
int _1276926;
_1276926 = _1276923 + x_1276925;
float* idx_1276927;
idx_1276927 = _1013472_1276782 + _1276926;
_1276930 = __ldg(idx_1276927);
p_1276930 = _1276930;
l1276928: ;
_1276930 = p_1276930;
p_1276933 = _1276930;
goto l1276931;
l1276931: ;
_1276933 = p_1276933;
if (_1276811) goto l1276934; else goto l1276998;
l1276998: ;
pbh_upper_1276937 = _1277000;
goto l1276935;
l1276934: ;
union variant_220130 _1265919_7712;
_1265919_7712.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7714;
_1265920_7714.e0 = 1;
_1265920_7714.e1 = _1265919_7712;
pbh_upper_1276937 = _1265920_7714;
goto l1276935;
l1276935: ;
bh_upper_1276937 = pbh_upper_1276937;
int _1276938;
_1276938 = 1 + gid_y_1276821;
bool _1276939;
_1276939 = _1276816 <= _1276938;
if (_1276939) goto l1276940; else goto l1276995;
l1276995: ;
union variant_220130 _1276996;
_1276996.qs32 = _1276938;
struct_BoundaryMode_220129 _1276997;
_1276997.e0 = 0;
_1276997.e1 = _1276996;
pbh_upper_1276943 = _1276997;
goto l1276941;
l1276940: ;
union variant_220130 _1265919_7722;
_1265919_7722.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7724;
_1265920_7724.e0 = 1;
_1265920_7724.e1 = _1265919_7722;
pbh_upper_1276943 = _1265920_7724;
goto l1276941;
l1276941: ;
bh_upper_1276943 = pbh_upper_1276943;
unsigned int _1276946;
_1276946 = bh_upper_1276943.e0;
union variant_220130 _1276953;
_1276953 = bh_upper_1276937.e1;
union variant_220130 _1276950;
_1276950 = bh_upper_1276943.e1;
bool _1276947;
_1276947 = _1276946 == 0;
unsigned int _1276944;
_1276944 = bh_upper_1276937.e0;
bool _1276945;
_1276945 = _1276944 == 0;
bool _1276948;
_1276948 = _1276945 & _1276947;
if (_1276948) goto l1276949; else goto l1276986;
l1276986: ;
bool _1276987;
_1276987 = _1276944 == 1;
if (_1276987) goto l1276988; else goto l1276990;
l1276990: ;
bool _1276991;
_1276991 = _1276946 == 1;
if (_1276991) goto l1276992; else goto l1276994;
l1276994: ;
// bottom: float r4_1265918_7736;
// bottom: p_1276962 = r4_1265918_7736;
goto l1276960;
l1276992: ;
float c_1276993;
c_1276993 = _1276950.pf32;
p_1276962 = c_1276993;
goto l1276960;
l1276988: ;
float c_1276989;
c_1276989 = _1276953.pf32;
p_1276962 = c_1276989;
goto l1276960;
l1276949: ;
int x_1276954;
x_1276954 = _1276953.qs32;
int y_1276951;
y_1276951 = _1276950.qs32;
int _1276952;
_1276952 = y_1276951 * _1276835;
int _1276955;
_1276955 = _1276952 + x_1276954;
float* idx_1276956;
idx_1276956 = _1013472_1276782 + _1276955;
_1276959 = __ldg(idx_1276956);
p_1276959 = _1276959;
l1276957: ;
_1276959 = p_1276959;
p_1276962 = _1276959;
goto l1276960;
l1276960: ;
_1276962 = p_1276962;
float _1276980;
_1276980 = 2.500000e-01f * _1276933;
int _1276963;
_1276963 = _1013471_1276781.e3;
float _1276982;
_1276982 = 2.500000e-01f * _1276962;
float _1276973;
_1276973 = _1276972;
float _1276974;
_1276974 = 2.000000e-01f * _1276973;
float _1276976;
_1276976 = 2.500000e-01f * _1276875;
float _1276978;
_1276978 = 2.500000e-01f * _1276904;
int _1276964;
_1276964 = gid_y_1276821 * _1276963;
float _1276967;
_1276967 = 2.000000e-01f * _1276846;
float _1276975;
_1276975 = _1276967 + _1276974;
float _1276977;
_1276977 = 0.000000e+00f + _1276976;
float _1276979;
_1276979 = _1276977 + _1276978;
int _1276965;
_1276965 = _1276964 + gid_x_1276810;
float _1276981;
_1276981 = _1276979 + _1276980;
float* idx_1276966;
idx_1276966 = _1013470_1276780 + _1276965;
float _1276983;
_1276983 = _1276981 + _1276982;
float val_1276984;
val_1276984 = _1276975 + _1276983;
*idx_1276966 = val_1276984;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1039854(struct_Img_220118 _1039857_1272099, struct_Img_220118 _1039858_1272100, float* _1039859_1272101, struct_Img_220118 _1039860_1272102, float* _1039861_1272103, float* _1039862_1272104) {
int _1272107;
int p_1272107;
int _1272110;
int p_1272110;
int _1272113;
int p_1272113;
int _1272116;
int p_1272116;
int _1272119;
int p_1272119;
int _1272122;
int p_1272122;
int _1272125;
int p_1272125;
float _1272138;
float p_1272138;
float _1272152;
float p_1272152;
float _1272157;
float p_1272157;
float _1272162;
float p_1272162;
float _1272170;
float p_1272170;
_1272107 = threadIdx_x();
p_1272107 = _1272107;
l1272105: ;
_1272107 = p_1272107;
_1272110 = blockDim_x();
p_1272110 = _1272110;
l1272108: ;
_1272110 = p_1272110;
_1272113 = blockIdx_x();
p_1272113 = _1272113;
l1272111: ;
_1272113 = p_1272113;
_1272116 = threadIdx_y();
p_1272116 = _1272116;
l1272114: ;
_1272116 = p_1272116;
_1272119 = blockDim_y();
p_1272119 = _1272119;
l1272117: ;
_1272119 = p_1272119;
_1272122 = blockIdx_y();
p_1272122 = _1272122;
l1272120: ;
_1272122 = p_1272122;
_1272125 = blockDim_y();
p_1272125 = _1272125;
l1272123: ;
_1272125 = p_1272125;
int _1272129;
_1272129 = _1039857_1272099.e3;
int _1272131;
_1272131 = _1272110 * _1272113;
int gid_x_1272132;
gid_x_1272132 = _1272107 + _1272131;
int _1272126;
_1272126 = _1272119 * _1272122;
int gid_y_1272127;
gid_y_1272127 = _1272116 + _1272126;
int _1272128;
_1272128 = 1 + gid_y_1272127;
int _1272130;
_1272130 = _1272128 * _1272129;
int _1272133;
_1272133 = _1272130 + gid_x_1272132;
int _1272134;
_1272134 = 128 + _1272133;
float* idx_1272135;
idx_1272135 = _1039859_1272101 + _1272134;
_1272138 = __ldg(idx_1272135);
p_1272138 = _1272138;
l1272136: ;
_1272138 = p_1272138;
int _1272139;
_1272139 = _1039860_1272102.e3;
int _1272146;
_1272146 = gid_y_1272127 * _1272129;
int _1272140;
_1272140 = _1272128 * _1272139;
int _1272141;
_1272141 = _1272140 + gid_x_1272132;
int _1272147;
_1272147 = _1272146 + gid_x_1272132;
int _1272142;
_1272142 = 128 + _1272141;
int _1272148;
_1272148 = 128 + _1272147;
float* idx_1272143;
idx_1272143 = _1039862_1272104 + _1272142;
float* idx_1272149;
idx_1272149 = _1039859_1272101 + _1272148;
float _1272144;
_1272144 = *idx_1272143;
_1272152 = __ldg(idx_1272149);
p_1272152 = _1272152;
l1272150: ;
_1272152 = p_1272152;
int _1272153;
_1272153 = 127 + _1272133;
float* idx_1272154;
idx_1272154 = _1039859_1272101 + _1272153;
_1272157 = __ldg(idx_1272154);
p_1272157 = _1272157;
l1272155: ;
_1272157 = p_1272157;
int _1272158;
_1272158 = 129 + _1272133;
float* idx_1272159;
idx_1272159 = _1039859_1272101 + _1272158;
_1272162 = __ldg(idx_1272159);
p_1272162 = _1272162;
l1272160: ;
_1272162 = p_1272162;
int _1272163;
_1272163 = 2 + gid_y_1272127;
int _1272164;
_1272164 = _1272163 * _1272129;
int _1272165;
_1272165 = _1272164 + gid_x_1272132;
int _1272166;
_1272166 = 128 + _1272165;
float* idx_1272167;
idx_1272167 = _1039859_1272101 + _1272166;
_1272170 = __ldg(idx_1272167);
p_1272170 = _1272170;
l1272168: ;
_1272170 = p_1272170;
float _1272186;
_1272186 = 2.500000e-01f * _1272170;
float _1272177;
_1272177 = _1272144;
float _1272182;
_1272182 = 2.500000e-01f * _1272157;
float _1272184;
_1272184 = 2.500000e-01f * _1272162;
float _1272178;
_1272178 = 2.000000e-01f * _1272177;
float _1272180;
_1272180 = 2.500000e-01f * _1272152;
int _1272171;
_1272171 = _1039858_1272100.e3;
float _1272176;
_1272176 = 2.000000e-01f * _1272138;
float _1272181;
_1272181 = 0.000000e+00f + _1272180;
float _1272183;
_1272183 = _1272181 + _1272182;
float _1272185;
_1272185 = _1272183 + _1272184;
float _1272179;
_1272179 = _1272176 + _1272178;
int _1272172;
_1272172 = _1272128 * _1272171;
float _1272187;
_1272187 = _1272185 + _1272186;
float val_1272188;
val_1272188 = _1272179 + _1272187;
int _1272173;
_1272173 = _1272172 + gid_x_1272132;
int _1272174;
_1272174 = 128 + _1272173;
float* idx_1272175;
idx_1272175 = _1039861_1272103 + _1272174;
*idx_1272175 = val_1272188;
return ;
}
__global__ __launch_bounds__ (64 * 2 * 1) void lambda_1018505(float* _1018508_1279004, float* _1018509_1279005, struct_Img_220118 _1018510_1279006, struct_Img_220118 _1018511_1279007, float* _1018512_1279008, struct_Img_220118 _1018513_1279009) {
int tid_x_1279012;
int ptid_x_1279012;
int tid_y_1279015;
int ptid_y_1279015;
int threadIdx_y_1279018;
int pthreadIdx_y_1279018;
int blockDim_y_1279021;
int pblockDim_y_1279021;
int blockIdx_y_1279024;
int pblockIdx_y_1279024;
float* spm_1279031;
float* pspm_1279031;
int _1279034;
int p_1279034;
int _1279037;
int p_1279037;
int _1279040;
int p_1279040;
int _1279043;
int p_1279043;
int _1279046;
int p_1279046;
int _1279049;
int p_1279049;
int _1279052;
int p_1279052;
int _1279055;
int p_1279055;
struct_BoundaryMode_220129 bh_lower_1279062;
struct_BoundaryMode_220129 pbh_lower_1279062;
struct_BoundaryMode_220129 map_boundary_mode_1279073;
struct_BoundaryMode_220129 pmap_boundary_mode_1279073;
struct_BoundaryMode_220129 map_boundary_mode_1279076;
struct_BoundaryMode_220129 pmap_boundary_mode_1279076;
struct_BoundaryMode_220129 bh_lower_1279084;
struct_BoundaryMode_220129 pbh_lower_1279084;
struct_BoundaryMode_220129 map_boundary_mode_1279095;
struct_BoundaryMode_220129 pmap_boundary_mode_1279095;
struct_BoundaryMode_220129 map_boundary_mode_1279098;
struct_BoundaryMode_220129 pmap_boundary_mode_1279098;
float _1279115;
float p_1279115;
float _1279118;
float p_1279118;
struct_BoundaryMode_220129 bh_lower_1279124;
struct_BoundaryMode_220129 pbh_lower_1279124;
struct_BoundaryMode_220129 map_boundary_mode_1279134;
struct_BoundaryMode_220129 pmap_boundary_mode_1279134;
struct_BoundaryMode_220129 map_boundary_mode_1279137;
struct_BoundaryMode_220129 pmap_boundary_mode_1279137;
struct_BoundaryMode_220129 bh_lower_1279142;
struct_BoundaryMode_220129 pbh_lower_1279142;
struct_BoundaryMode_220129 map_boundary_mode_1279152;
struct_BoundaryMode_220129 pmap_boundary_mode_1279152;
struct_BoundaryMode_220129 map_boundary_mode_1279155;
struct_BoundaryMode_220129 pmap_boundary_mode_1279155;
float _1279171;
float p_1279171;
float _1279174;
float p_1279174;
struct_BoundaryMode_220129 bh_lower_1279178;
struct_BoundaryMode_220129 pbh_lower_1279178;
struct_BoundaryMode_220129 map_boundary_mode_1279188;
struct_BoundaryMode_220129 pmap_boundary_mode_1279188;
struct_BoundaryMode_220129 map_boundary_mode_1279191;
struct_BoundaryMode_220129 pmap_boundary_mode_1279191;
struct_BoundaryMode_220129 bh_lower_1279195;
struct_BoundaryMode_220129 pbh_lower_1279195;
struct_BoundaryMode_220129 map_boundary_mode_1279205;
struct_BoundaryMode_220129 pmap_boundary_mode_1279205;
struct_BoundaryMode_220129 map_boundary_mode_1279208;
struct_BoundaryMode_220129 pmap_boundary_mode_1279208;
float _1279224;
float p_1279224;
float _1279227;
float p_1279227;
struct_BoundaryMode_220129 bh_lower_1279233;
struct_BoundaryMode_220129 pbh_lower_1279233;
struct_BoundaryMode_220129 map_boundary_mode_1279243;
struct_BoundaryMode_220129 pmap_boundary_mode_1279243;
struct_BoundaryMode_220129 map_boundary_mode_1279246;
struct_BoundaryMode_220129 pmap_boundary_mode_1279246;
struct_BoundaryMode_220129 bh_lower_1279250;
struct_BoundaryMode_220129 pbh_lower_1279250;
struct_BoundaryMode_220129 map_boundary_mode_1279260;
struct_BoundaryMode_220129 pmap_boundary_mode_1279260;
struct_BoundaryMode_220129 map_boundary_mode_1279263;
struct_BoundaryMode_220129 pmap_boundary_mode_1279263;
float _1279279;
float p_1279279;
float _1279282;
float p_1279282;
struct_BoundaryMode_220129 bh_lower_1279286;
struct_BoundaryMode_220129 pbh_lower_1279286;
struct_BoundaryMode_220129 map_boundary_mode_1279296;
struct_BoundaryMode_220129 pmap_boundary_mode_1279296;
struct_BoundaryMode_220129 map_boundary_mode_1279299;
struct_BoundaryMode_220129 pmap_boundary_mode_1279299;
struct_BoundaryMode_220129 bh_lower_1279305;
struct_BoundaryMode_220129 pbh_lower_1279305;
struct_BoundaryMode_220129 map_boundary_mode_1279315;
struct_BoundaryMode_220129 pmap_boundary_mode_1279315;
struct_BoundaryMode_220129 map_boundary_mode_1279318;
struct_BoundaryMode_220129 pmap_boundary_mode_1279318;
float _1279334;
float p_1279334;
float _1279337;
float p_1279337;
int _1279378;
int p_1279378;
int _1279381;
int p_1279381;
int _1279384;
int p_1279384;
int _1279387;
int p_1279387;
tid_x_1279012 = threadIdx_x();
ptid_x_1279012 = tid_x_1279012;
l1279010: ;
tid_x_1279012 = ptid_x_1279012;
tid_y_1279015 = threadIdx_y();
ptid_y_1279015 = tid_y_1279015;
l1279013: ;
tid_y_1279015 = ptid_y_1279015;
threadIdx_y_1279018 = threadIdx_y();
pthreadIdx_y_1279018 = threadIdx_y_1279018;
l1279016: ;
threadIdx_y_1279018 = pthreadIdx_y_1279018;
blockDim_y_1279021 = blockDim_y();
pblockDim_y_1279021 = blockDim_y_1279021;
l1279019: ;
blockDim_y_1279021 = pblockDim_y_1279021;
blockIdx_y_1279024 = blockIdx_y();
pblockIdx_y_1279024 = blockIdx_y_1279024;
l1279022: ;
blockIdx_y_1279024 = pblockIdx_y_1279024;
__shared__ float reserver_spm_1279031[128];
pspm_1279031 = reserver_spm_1279031;
l1279029: ;
spm_1279031 = pspm_1279031;
_1279034 = blockDim_x();
p_1279034 = _1279034;
l1279032: ;
_1279034 = p_1279034;
_1279037 = blockIdx_x();
p_1279037 = _1279037;
l1279035: ;
_1279037 = p_1279037;
_1279040 = blockDim_y();
p_1279040 = _1279040;
l1279038: ;
_1279040 = p_1279040;
_1279043 = blockIdx_y();
p_1279043 = _1279043;
l1279041: ;
_1279043 = p_1279043;
_1279046 = blockDim_x();
p_1279046 = _1279046;
l1279044: ;
_1279046 = p_1279046;
_1279049 = blockIdx_x();
p_1279049 = _1279049;
l1279047: ;
_1279049 = p_1279049;
_1279052 = blockDim_y();
p_1279052 = _1279052;
l1279050: ;
_1279052 = p_1279052;
_1279055 = blockIdx_y();
p_1279055 = _1279055;
l1279053: ;
_1279055 = p_1279055;
int _1279056;
_1279056 = _1279046 * _1279049;
int _1279057;
_1279057 = tid_x_1279012 + _1279056;
union variant_220130 _1279451;
_1279451.qs32 = _1279057;
struct_BoundaryMode_220129 _1279452;
_1279452.e0 = 0;
_1279452.e1 = _1279451;
int _1279349;
_1279349 = _1279034 * _1279037;
int _1279346;
_1279346 = _1018510_1279006.e3;
int _1279344;
_1279344 = _1279040 * _1279043;
int _1279345;
_1279345 = tid_y_1279015 + _1279344;
int _1279347;
_1279347 = _1279345 * _1279346;
bool _1279058;
_1279058 = _1279057 < 0;
int _1279348;
_1279348 = _1279347 + tid_x_1279012;
int _1279350;
_1279350 = _1279348 + _1279349;
float* idx_1279351;
idx_1279351 = _1018512_1279008 + _1279350;
float _1279352;
_1279352 = *idx_1279351;
if (_1279058) goto l1279059; else goto l1279537;
l1279537: ;
pbh_lower_1279062 = _1279452;
goto l1279060;
l1279059: ;
union variant_220130 _1265919_7770;
_1265919_7770.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7772;
_1265920_7772.e0 = 1;
_1265920_7772.e1 = _1265919_7770;
pbh_lower_1279062 = _1265920_7772;
goto l1279060;
l1279060: ;
bh_lower_1279062 = pbh_lower_1279062;
unsigned int _1279063;
_1279063 = bh_lower_1279062.e0;
int _1279066;
_1279066 = _1018513_1279009.e1;
bool _1279064;
_1279064 = _1279063 == 0;
if (_1279064) goto l1279065; else goto l1279535;
l1279535: ;
pmap_boundary_mode_1279076 = bh_lower_1279062;
goto l1279074;
l1279065: ;
union variant_220130 _1279067;
_1279067 = bh_lower_1279062.e1;
int idx_1279068;
idx_1279068 = _1279067.qs32;
bool _1279069;
_1279069 = _1279066 <= idx_1279068;
if (_1279069) goto l1279070; else goto l1279532;
l1279532: ;
union variant_220130 _1279533;
_1279533.qs32 = idx_1279068;
struct_BoundaryMode_220129 _1279534;
_1279534.e0 = 0;
_1279534.e1 = _1279533;
pmap_boundary_mode_1279073 = _1279534;
goto l1279071;
l1279070: ;
union variant_220130 _1265919_7783;
_1265919_7783.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7785;
_1265920_7785.e0 = 1;
_1265920_7785.e1 = _1265919_7783;
pmap_boundary_mode_1279073 = _1265920_7785;
goto l1279071;
l1279071: ;
map_boundary_mode_1279073 = pmap_boundary_mode_1279073;
pmap_boundary_mode_1279076 = map_boundary_mode_1279073;
goto l1279074;
l1279074: ;
map_boundary_mode_1279076 = pmap_boundary_mode_1279076;
int _1279077;
_1279077 = _1279052 * _1279055;
int _1279078;
_1279078 = tid_y_1279015 + _1279077;
int _1279079;
_1279079 = -1 + _1279078;
bool _1279080;
_1279080 = _1279079 < 0;
if (_1279080) goto l1279081; else goto l1279529;
l1279529: ;
union variant_220130 _1279530;
_1279530.qs32 = _1279079;
struct_BoundaryMode_220129 _1279531;
_1279531.e0 = 0;
_1279531.e1 = _1279530;
pbh_lower_1279084 = _1279531;
goto l1279082;
l1279081: ;
union variant_220130 _1265919_7794;
_1265919_7794.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7796;
_1265920_7796.e0 = 1;
_1265920_7796.e1 = _1265919_7794;
pbh_lower_1279084 = _1265920_7796;
goto l1279082;
l1279082: ;
bh_lower_1279084 = pbh_lower_1279084;
unsigned int _1279085;
_1279085 = bh_lower_1279084.e0;
bool _1279086;
_1279086 = _1279085 == 0;
int _1279088;
_1279088 = _1018513_1279009.e2;
if (_1279086) goto l1279087; else goto l1279528;
l1279528: ;
pmap_boundary_mode_1279098 = bh_lower_1279084;
goto l1279096;
l1279087: ;
union variant_220130 _1279089;
_1279089 = bh_lower_1279084.e1;
int idx_1279090;
idx_1279090 = _1279089.qs32;
bool _1279091;
_1279091 = _1279088 <= idx_1279090;
if (_1279091) goto l1279092; else goto l1279525;
l1279525: ;
union variant_220130 _1279526;
_1279526.qs32 = idx_1279090;
struct_BoundaryMode_220129 _1279527;
_1279527.e0 = 0;
_1279527.e1 = _1279526;
pmap_boundary_mode_1279095 = _1279527;
goto l1279093;
l1279092: ;
union variant_220130 _1265919_7807;
_1265919_7807.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7809;
_1265920_7809.e0 = 1;
_1265920_7809.e1 = _1265919_7807;
pmap_boundary_mode_1279095 = _1265920_7809;
goto l1279093;
l1279093: ;
map_boundary_mode_1279095 = pmap_boundary_mode_1279095;
pmap_boundary_mode_1279098 = map_boundary_mode_1279095;
goto l1279096;
l1279096: ;
map_boundary_mode_1279098 = pmap_boundary_mode_1279098;
unsigned int _1279101;
_1279101 = map_boundary_mode_1279098.e0;
unsigned int _1279099;
_1279099 = map_boundary_mode_1279076.e0;
int _1279107;
_1279107 = _1018513_1279009.e3;
bool _1279102;
_1279102 = _1279101 == 0;
union variant_220130 _1279105;
_1279105 = map_boundary_mode_1279098.e1;
union variant_220130 _1279109;
_1279109 = map_boundary_mode_1279076.e1;
bool _1279100;
_1279100 = _1279099 == 0;
bool _1279103;
_1279103 = _1279100 & _1279102;
if (_1279103) goto l1279104; else goto l1279516;
l1279516: ;
bool _1279517;
_1279517 = _1279099 == 1;
if (_1279517) goto l1279518; else goto l1279520;
l1279520: ;
bool _1279521;
_1279521 = _1279101 == 1;
if (_1279521) goto l1279522; else goto l1279524;
l1279524: ;
// bottom: float r4_1265918_7822;
// bottom: p_1279118 = r4_1265918_7822;
goto l1279116;
l1279522: ;
float c_1279523;
c_1279523 = _1279105.pf32;
p_1279118 = c_1279523;
goto l1279116;
l1279518: ;
float c_1279519;
c_1279519 = _1279109.pf32;
p_1279118 = c_1279519;
goto l1279116;
l1279104: ;
int x_1279110;
x_1279110 = _1279109.qs32;
int y_1279106;
y_1279106 = _1279105.qs32;
int _1279108;
_1279108 = y_1279106 * _1279107;
int _1279111;
_1279111 = _1279108 + x_1279110;
float* idx_1279112;
idx_1279112 = _1018509_1279005 + _1279111;
_1279115 = __ldg(idx_1279112);
p_1279115 = _1279115;
l1279113: ;
_1279115 = p_1279115;
p_1279118 = _1279115;
goto l1279116;
l1279116: ;
_1279118 = p_1279118;
int _1279119;
_1279119 = -1 + _1279057;
bool _1279120;
_1279120 = _1279119 < 0;
if (_1279120) goto l1279121; else goto l1279513;
l1279513: ;
union variant_220130 _1279514;
_1279514.qs32 = _1279119;
struct_BoundaryMode_220129 _1279515;
_1279515.e0 = 0;
_1279515.e1 = _1279514;
pbh_lower_1279124 = _1279515;
goto l1279122;
l1279121: ;
union variant_220130 _1265919_7828;
_1265919_7828.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7830;
_1265920_7830.e0 = 1;
_1265920_7830.e1 = _1265919_7828;
pbh_lower_1279124 = _1265920_7830;
goto l1279122;
l1279122: ;
bh_lower_1279124 = pbh_lower_1279124;
unsigned int _1279125;
_1279125 = bh_lower_1279124.e0;
bool _1279126;
_1279126 = _1279125 == 0;
if (_1279126) goto l1279127; else goto l1279512;
l1279512: ;
pmap_boundary_mode_1279137 = bh_lower_1279124;
goto l1279135;
l1279127: ;
union variant_220130 _1279128;
_1279128 = bh_lower_1279124.e1;
int idx_1279129;
idx_1279129 = _1279128.qs32;
bool _1279130;
_1279130 = _1279066 <= idx_1279129;
if (_1279130) goto l1279131; else goto l1279509;
l1279509: ;
union variant_220130 _1279510;
_1279510.qs32 = idx_1279129;
struct_BoundaryMode_220129 _1279511;
_1279511.e0 = 0;
_1279511.e1 = _1279510;
pmap_boundary_mode_1279134 = _1279511;
goto l1279132;
l1279131: ;
union variant_220130 _1265919_7840;
_1265919_7840.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7842;
_1265920_7842.e0 = 1;
_1265920_7842.e1 = _1265919_7840;
pmap_boundary_mode_1279134 = _1265920_7842;
goto l1279132;
l1279132: ;
map_boundary_mode_1279134 = pmap_boundary_mode_1279134;
pmap_boundary_mode_1279137 = map_boundary_mode_1279134;
goto l1279135;
l1279135: ;
map_boundary_mode_1279137 = pmap_boundary_mode_1279137;
union variant_220130 _1279467;
_1279467.qs32 = _1279078;
struct_BoundaryMode_220129 _1279468;
_1279468.e0 = 0;
_1279468.e1 = _1279467;
bool _1279138;
_1279138 = _1279078 < 0;
if (_1279138) goto l1279139; else goto l1279508;
l1279508: ;
pbh_lower_1279142 = _1279468;
goto l1279140;
l1279139: ;
union variant_220130 _1265919_7850;
_1265919_7850.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7852;
_1265920_7852.e0 = 1;
_1265920_7852.e1 = _1265919_7850;
pbh_lower_1279142 = _1265920_7852;
goto l1279140;
l1279140: ;
bh_lower_1279142 = pbh_lower_1279142;
unsigned int _1279143;
_1279143 = bh_lower_1279142.e0;
bool _1279144;
_1279144 = _1279143 == 0;
if (_1279144) goto l1279145; else goto l1279507;
l1279507: ;
pmap_boundary_mode_1279155 = bh_lower_1279142;
goto l1279153;
l1279145: ;
union variant_220130 _1279146;
_1279146 = bh_lower_1279142.e1;
int idx_1279147;
idx_1279147 = _1279146.qs32;
bool _1279148;
_1279148 = _1279088 <= idx_1279147;
if (_1279148) goto l1279149; else goto l1279504;
l1279504: ;
union variant_220130 _1279505;
_1279505.qs32 = idx_1279147;
struct_BoundaryMode_220129 _1279506;
_1279506.e0 = 0;
_1279506.e1 = _1279505;
pmap_boundary_mode_1279152 = _1279506;
goto l1279150;
l1279149: ;
union variant_220130 _1265919_7862;
_1265919_7862.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7864;
_1265920_7864.e0 = 1;
_1265920_7864.e1 = _1265919_7862;
pmap_boundary_mode_1279152 = _1265920_7864;
goto l1279150;
l1279150: ;
map_boundary_mode_1279152 = pmap_boundary_mode_1279152;
pmap_boundary_mode_1279155 = map_boundary_mode_1279152;
goto l1279153;
l1279153: ;
map_boundary_mode_1279155 = pmap_boundary_mode_1279155;
unsigned int _1279156;
_1279156 = map_boundary_mode_1279137.e0;
union variant_220130 _1279165;
_1279165 = map_boundary_mode_1279137.e1;
union variant_220130 _1279162;
_1279162 = map_boundary_mode_1279155.e1;
bool _1279157;
_1279157 = _1279156 == 0;
unsigned int _1279158;
_1279158 = map_boundary_mode_1279155.e0;
bool _1279159;
_1279159 = _1279158 == 0;
bool _1279160;
_1279160 = _1279157 & _1279159;
if (_1279160) goto l1279161; else goto l1279495;
l1279495: ;
bool _1279496;
_1279496 = _1279156 == 1;
if (_1279496) goto l1279497; else goto l1279499;
l1279499: ;
bool _1279500;
_1279500 = _1279158 == 1;
if (_1279500) goto l1279501; else goto l1279503;
l1279503: ;
// bottom: float r4_1265918_7876;
// bottom: p_1279174 = r4_1265918_7876;
goto l1279172;
l1279501: ;
float c_1279502;
c_1279502 = _1279162.pf32;
p_1279174 = c_1279502;
goto l1279172;
l1279497: ;
float c_1279498;
c_1279498 = _1279165.pf32;
p_1279174 = c_1279498;
goto l1279172;
l1279161: ;
int x_1279166;
x_1279166 = _1279165.qs32;
int y_1279163;
y_1279163 = _1279162.qs32;
int _1279164;
_1279164 = y_1279163 * _1279107;
int _1279167;
_1279167 = _1279164 + x_1279166;
float* idx_1279168;
idx_1279168 = _1018509_1279005 + _1279167;
_1279171 = __ldg(idx_1279168);
p_1279171 = _1279171;
l1279169: ;
_1279171 = p_1279171;
p_1279174 = _1279171;
goto l1279172;
l1279172: ;
_1279174 = p_1279174;
if (_1279058) goto l1279175; else goto l1279494;
l1279494: ;
pbh_lower_1279178 = _1279452;
goto l1279176;
l1279175: ;
union variant_220130 _1265919_7877;
_1265919_7877.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7879;
_1265920_7879.e0 = 1;
_1265920_7879.e1 = _1265919_7877;
pbh_lower_1279178 = _1265920_7879;
goto l1279176;
l1279176: ;
bh_lower_1279178 = pbh_lower_1279178;
unsigned int _1279179;
_1279179 = bh_lower_1279178.e0;
bool _1279180;
_1279180 = _1279179 == 0;
if (_1279180) goto l1279181; else goto l1279493;
l1279493: ;
pmap_boundary_mode_1279191 = bh_lower_1279178;
goto l1279189;
l1279181: ;
union variant_220130 _1279182;
_1279182 = bh_lower_1279178.e1;
int idx_1279183;
idx_1279183 = _1279182.qs32;
bool _1279184;
_1279184 = _1279066 <= idx_1279183;
if (_1279184) goto l1279185; else goto l1279490;
l1279490: ;
union variant_220130 _1279491;
_1279491.qs32 = idx_1279183;
struct_BoundaryMode_220129 _1279492;
_1279492.e0 = 0;
_1279492.e1 = _1279491;
pmap_boundary_mode_1279188 = _1279492;
goto l1279186;
l1279185: ;
union variant_220130 _1265919_7889;
_1265919_7889.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7891;
_1265920_7891.e0 = 1;
_1265920_7891.e1 = _1265919_7889;
pmap_boundary_mode_1279188 = _1265920_7891;
goto l1279186;
l1279186: ;
map_boundary_mode_1279188 = pmap_boundary_mode_1279188;
pmap_boundary_mode_1279191 = map_boundary_mode_1279188;
goto l1279189;
l1279189: ;
map_boundary_mode_1279191 = pmap_boundary_mode_1279191;
if (_1279138) goto l1279192; else goto l1279489;
l1279489: ;
pbh_lower_1279195 = _1279468;
goto l1279193;
l1279192: ;
union variant_220130 _1265919_7895;
_1265919_7895.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7897;
_1265920_7897.e0 = 1;
_1265920_7897.e1 = _1265919_7895;
pbh_lower_1279195 = _1265920_7897;
goto l1279193;
l1279193: ;
bh_lower_1279195 = pbh_lower_1279195;
unsigned int _1279196;
_1279196 = bh_lower_1279195.e0;
bool _1279197;
_1279197 = _1279196 == 0;
if (_1279197) goto l1279198; else goto l1279488;
l1279488: ;
pmap_boundary_mode_1279208 = bh_lower_1279195;
goto l1279206;
l1279198: ;
union variant_220130 _1279199;
_1279199 = bh_lower_1279195.e1;
int idx_1279200;
idx_1279200 = _1279199.qs32;
bool _1279201;
_1279201 = _1279088 <= idx_1279200;
if (_1279201) goto l1279202; else goto l1279485;
l1279485: ;
union variant_220130 _1279486;
_1279486.qs32 = idx_1279200;
struct_BoundaryMode_220129 _1279487;
_1279487.e0 = 0;
_1279487.e1 = _1279486;
pmap_boundary_mode_1279205 = _1279487;
goto l1279203;
l1279202: ;
union variant_220130 _1265919_7907;
_1265919_7907.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7909;
_1265920_7909.e0 = 1;
_1265920_7909.e1 = _1265919_7907;
pmap_boundary_mode_1279205 = _1265920_7909;
goto l1279203;
l1279203: ;
map_boundary_mode_1279205 = pmap_boundary_mode_1279205;
pmap_boundary_mode_1279208 = map_boundary_mode_1279205;
goto l1279206;
l1279206: ;
map_boundary_mode_1279208 = pmap_boundary_mode_1279208;
union variant_220130 _1279215;
_1279215 = map_boundary_mode_1279208.e1;
unsigned int _1279211;
_1279211 = map_boundary_mode_1279208.e0;
union variant_220130 _1279218;
_1279218 = map_boundary_mode_1279191.e1;
unsigned int _1279209;
_1279209 = map_boundary_mode_1279191.e0;
bool _1279212;
_1279212 = _1279211 == 0;
bool _1279210;
_1279210 = _1279209 == 0;
bool _1279213;
_1279213 = _1279210 & _1279212;
if (_1279213) goto l1279214; else goto l1279476;
l1279476: ;
bool _1279477;
_1279477 = _1279209 == 1;
if (_1279477) goto l1279478; else goto l1279480;
l1279480: ;
bool _1279481;
_1279481 = _1279211 == 1;
if (_1279481) goto l1279482; else goto l1279484;
l1279484: ;
// bottom: float r4_1265918_7921;
// bottom: p_1279227 = r4_1265918_7921;
goto l1279225;
l1279482: ;
float c_1279483;
c_1279483 = _1279215.pf32;
p_1279227 = c_1279483;
goto l1279225;
l1279478: ;
float c_1279479;
c_1279479 = _1279218.pf32;
p_1279227 = c_1279479;
goto l1279225;
l1279214: ;
int x_1279219;
x_1279219 = _1279218.qs32;
int y_1279216;
y_1279216 = _1279215.qs32;
int _1279217;
_1279217 = y_1279216 * _1279107;
int _1279220;
_1279220 = _1279217 + x_1279219;
float* idx_1279221;
idx_1279221 = _1018509_1279005 + _1279220;
_1279224 = __ldg(idx_1279221);
p_1279224 = _1279224;
l1279222: ;
_1279224 = p_1279224;
p_1279227 = _1279224;
goto l1279225;
l1279225: ;
_1279227 = p_1279227;
int _1279228;
_1279228 = 1 + _1279057;
bool _1279229;
_1279229 = _1279228 < 0;
if (_1279229) goto l1279230; else goto l1279473;
l1279473: ;
union variant_220130 _1279474;
_1279474.qs32 = _1279228;
struct_BoundaryMode_220129 _1279475;
_1279475.e0 = 0;
_1279475.e1 = _1279474;
pbh_lower_1279233 = _1279475;
goto l1279231;
l1279230: ;
union variant_220130 _1265919_7927;
_1265919_7927.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7929;
_1265920_7929.e0 = 1;
_1265920_7929.e1 = _1265919_7927;
pbh_lower_1279233 = _1265920_7929;
goto l1279231;
l1279231: ;
bh_lower_1279233 = pbh_lower_1279233;
unsigned int _1279234;
_1279234 = bh_lower_1279233.e0;
bool _1279235;
_1279235 = _1279234 == 0;
if (_1279235) goto l1279236; else goto l1279472;
l1279472: ;
pmap_boundary_mode_1279246 = bh_lower_1279233;
goto l1279244;
l1279236: ;
union variant_220130 _1279237;
_1279237 = bh_lower_1279233.e1;
int idx_1279238;
idx_1279238 = _1279237.qs32;
bool _1279239;
_1279239 = _1279066 <= idx_1279238;
if (_1279239) goto l1279240; else goto l1279469;
l1279469: ;
union variant_220130 _1279470;
_1279470.qs32 = idx_1279238;
struct_BoundaryMode_220129 _1279471;
_1279471.e0 = 0;
_1279471.e1 = _1279470;
pmap_boundary_mode_1279243 = _1279471;
goto l1279241;
l1279240: ;
union variant_220130 _1265919_7939;
_1265919_7939.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7941;
_1265920_7941.e0 = 1;
_1265920_7941.e1 = _1265919_7939;
pmap_boundary_mode_1279243 = _1265920_7941;
goto l1279241;
l1279241: ;
map_boundary_mode_1279243 = pmap_boundary_mode_1279243;
pmap_boundary_mode_1279246 = map_boundary_mode_1279243;
goto l1279244;
l1279244: ;
map_boundary_mode_1279246 = pmap_boundary_mode_1279246;
if (_1279138) goto l1279247; else goto l1279466;
l1279466: ;
pbh_lower_1279250 = _1279468;
goto l1279248;
l1279247: ;
union variant_220130 _1265919_7945;
_1265919_7945.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7947;
_1265920_7947.e0 = 1;
_1265920_7947.e1 = _1265919_7945;
pbh_lower_1279250 = _1265920_7947;
goto l1279248;
l1279248: ;
bh_lower_1279250 = pbh_lower_1279250;
unsigned int _1279251;
_1279251 = bh_lower_1279250.e0;
bool _1279252;
_1279252 = _1279251 == 0;
if (_1279252) goto l1279253; else goto l1279465;
l1279465: ;
pmap_boundary_mode_1279263 = bh_lower_1279250;
goto l1279261;
l1279253: ;
union variant_220130 _1279254;
_1279254 = bh_lower_1279250.e1;
int idx_1279255;
idx_1279255 = _1279254.qs32;
bool _1279256;
_1279256 = _1279088 <= idx_1279255;
if (_1279256) goto l1279257; else goto l1279462;
l1279462: ;
union variant_220130 _1279463;
_1279463.qs32 = idx_1279255;
struct_BoundaryMode_220129 _1279464;
_1279464.e0 = 0;
_1279464.e1 = _1279463;
pmap_boundary_mode_1279260 = _1279464;
goto l1279258;
l1279257: ;
union variant_220130 _1265919_7957;
_1265919_7957.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7959;
_1265920_7959.e0 = 1;
_1265920_7959.e1 = _1265919_7957;
pmap_boundary_mode_1279260 = _1265920_7959;
goto l1279258;
l1279258: ;
map_boundary_mode_1279260 = pmap_boundary_mode_1279260;
pmap_boundary_mode_1279263 = map_boundary_mode_1279260;
goto l1279261;
l1279261: ;
map_boundary_mode_1279263 = pmap_boundary_mode_1279263;
unsigned int _1279266;
_1279266 = map_boundary_mode_1279263.e0;
union variant_220130 _1279273;
_1279273 = map_boundary_mode_1279246.e1;
bool _1279267;
_1279267 = _1279266 == 0;
union variant_220130 _1279270;
_1279270 = map_boundary_mode_1279263.e1;
unsigned int _1279264;
_1279264 = map_boundary_mode_1279246.e0;
bool _1279265;
_1279265 = _1279264 == 0;
bool _1279268;
_1279268 = _1279265 & _1279267;
if (_1279268) goto l1279269; else goto l1279453;
l1279453: ;
bool _1279454;
_1279454 = _1279264 == 1;
if (_1279454) goto l1279455; else goto l1279457;
l1279457: ;
bool _1279458;
_1279458 = _1279266 == 1;
if (_1279458) goto l1279459; else goto l1279461;
l1279461: ;
// bottom: float r4_1265918_7971;
// bottom: p_1279282 = r4_1265918_7971;
goto l1279280;
l1279459: ;
float c_1279460;
c_1279460 = _1279270.pf32;
p_1279282 = c_1279460;
goto l1279280;
l1279455: ;
float c_1279456;
c_1279456 = _1279273.pf32;
p_1279282 = c_1279456;
goto l1279280;
l1279269: ;
int y_1279271;
y_1279271 = _1279270.qs32;
int x_1279274;
x_1279274 = _1279273.qs32;
int _1279272;
_1279272 = y_1279271 * _1279107;
int _1279275;
_1279275 = _1279272 + x_1279274;
float* idx_1279276;
idx_1279276 = _1018509_1279005 + _1279275;
_1279279 = __ldg(idx_1279276);
p_1279279 = _1279279;
l1279277: ;
_1279279 = p_1279279;
p_1279282 = _1279279;
goto l1279280;
l1279280: ;
_1279282 = p_1279282;
if (_1279058) goto l1279283; else goto l1279450;
l1279450: ;
pbh_lower_1279286 = _1279452;
goto l1279284;
l1279283: ;
union variant_220130 _1265919_7972;
_1265919_7972.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7974;
_1265920_7974.e0 = 1;
_1265920_7974.e1 = _1265919_7972;
pbh_lower_1279286 = _1265920_7974;
goto l1279284;
l1279284: ;
bh_lower_1279286 = pbh_lower_1279286;
unsigned int _1279287;
_1279287 = bh_lower_1279286.e0;
bool _1279288;
_1279288 = _1279287 == 0;
if (_1279288) goto l1279289; else goto l1279449;
l1279449: ;
pmap_boundary_mode_1279299 = bh_lower_1279286;
goto l1279297;
l1279289: ;
union variant_220130 _1279290;
_1279290 = bh_lower_1279286.e1;
int idx_1279291;
idx_1279291 = _1279290.qs32;
bool _1279292;
_1279292 = _1279066 <= idx_1279291;
if (_1279292) goto l1279293; else goto l1279446;
l1279446: ;
union variant_220130 _1279447;
_1279447.qs32 = idx_1279291;
struct_BoundaryMode_220129 _1279448;
_1279448.e0 = 0;
_1279448.e1 = _1279447;
pmap_boundary_mode_1279296 = _1279448;
goto l1279294;
l1279293: ;
union variant_220130 _1265919_7984;
_1265919_7984.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7986;
_1265920_7986.e0 = 1;
_1265920_7986.e1 = _1265919_7984;
pmap_boundary_mode_1279296 = _1265920_7986;
goto l1279294;
l1279294: ;
map_boundary_mode_1279296 = pmap_boundary_mode_1279296;
pmap_boundary_mode_1279299 = map_boundary_mode_1279296;
goto l1279297;
l1279297: ;
map_boundary_mode_1279299 = pmap_boundary_mode_1279299;
int _1279300;
_1279300 = 1 + _1279078;
bool _1279301;
_1279301 = _1279300 < 0;
if (_1279301) goto l1279302; else goto l1279443;
l1279443: ;
union variant_220130 _1279444;
_1279444.qs32 = _1279300;
struct_BoundaryMode_220129 _1279445;
_1279445.e0 = 0;
_1279445.e1 = _1279444;
pbh_lower_1279305 = _1279445;
goto l1279303;
l1279302: ;
union variant_220130 _1265919_7995;
_1265919_7995.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_7997;
_1265920_7997.e0 = 1;
_1265920_7997.e1 = _1265919_7995;
pbh_lower_1279305 = _1265920_7997;
goto l1279303;
l1279303: ;
bh_lower_1279305 = pbh_lower_1279305;
unsigned int _1279306;
_1279306 = bh_lower_1279305.e0;
bool _1279307;
_1279307 = _1279306 == 0;
if (_1279307) goto l1279308; else goto l1279442;
l1279442: ;
pmap_boundary_mode_1279318 = bh_lower_1279305;
goto l1279316;
l1279308: ;
union variant_220130 _1279309;
_1279309 = bh_lower_1279305.e1;
int idx_1279310;
idx_1279310 = _1279309.qs32;
bool _1279311;
_1279311 = _1279088 <= idx_1279310;
if (_1279311) goto l1279312; else goto l1279439;
l1279439: ;
union variant_220130 _1279440;
_1279440.qs32 = idx_1279310;
struct_BoundaryMode_220129 _1279441;
_1279441.e0 = 0;
_1279441.e1 = _1279440;
pmap_boundary_mode_1279315 = _1279441;
goto l1279313;
l1279312: ;
union variant_220130 _1265919_8007;
_1265919_8007.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8009;
_1265920_8009.e0 = 1;
_1265920_8009.e1 = _1265919_8007;
pmap_boundary_mode_1279315 = _1265920_8009;
goto l1279313;
l1279313: ;
map_boundary_mode_1279315 = pmap_boundary_mode_1279315;
pmap_boundary_mode_1279318 = map_boundary_mode_1279315;
goto l1279316;
l1279316: ;
map_boundary_mode_1279318 = pmap_boundary_mode_1279318;
unsigned int _1279321;
_1279321 = map_boundary_mode_1279318.e0;
union variant_220130 _1279328;
_1279328 = map_boundary_mode_1279299.e1;
unsigned int _1279319;
_1279319 = map_boundary_mode_1279299.e0;
bool _1279320;
_1279320 = _1279319 == 0;
union variant_220130 _1279325;
_1279325 = map_boundary_mode_1279318.e1;
bool _1279322;
_1279322 = _1279321 == 0;
bool _1279323;
_1279323 = _1279320 & _1279322;
if (_1279323) goto l1279324; else goto l1279430;
l1279430: ;
bool _1279431;
_1279431 = _1279319 == 1;
if (_1279431) goto l1279432; else goto l1279434;
l1279434: ;
bool _1279435;
_1279435 = _1279321 == 1;
if (_1279435) goto l1279436; else goto l1279438;
l1279438: ;
// bottom: float r4_1265918_8021;
// bottom: p_1279337 = r4_1265918_8021;
goto l1279335;
l1279436: ;
float c_1279437;
c_1279437 = _1279325.pf32;
p_1279337 = c_1279437;
goto l1279335;
l1279432: ;
float c_1279433;
c_1279433 = _1279328.pf32;
p_1279337 = c_1279433;
goto l1279335;
l1279324: ;
int x_1279329;
x_1279329 = _1279328.qs32;
int y_1279326;
y_1279326 = _1279325.qs32;
int _1279327;
_1279327 = y_1279326 * _1279107;
int _1279330;
_1279330 = _1279327 + x_1279329;
float* idx_1279331;
idx_1279331 = _1018509_1279005 + _1279330;
_1279334 = __ldg(idx_1279331);
p_1279334 = _1279334;
l1279332: ;
_1279334 = p_1279334;
p_1279337 = _1279334;
goto l1279335;
l1279335: ;
_1279337 = p_1279337;
int _1279341;
_1279341 = 64 * tid_y_1279015;
float _1279358;
_1279358 = -4.000000e+00f * _1279227;
float _1279362;
_1279362 = 1.000000e+00f * _1279337;
float _1279353;
_1279353 = _1279352;
int _1279342;
_1279342 = _1279341 + tid_x_1279012;
float _1279360;
_1279360 = 1.000000e+00f * _1279282;
float _1279354;
_1279354 = 1.000000e+00f * _1279118;
float _1279356;
_1279356 = 1.000000e+00f * _1279174;
float* idx_1279343;
idx_1279343 = spm_1279031 + _1279342;
float _1279355;
_1279355 = 0.000000e+00f + _1279354;
float _1279357;
_1279357 = _1279355 + _1279356;
float _1279359;
_1279359 = _1279357 + _1279358;
float _1279361;
_1279361 = _1279359 + _1279360;
float _1279363;
_1279363 = _1279361 + _1279362;
float val_1279364;
val_1279364 = _1279353 + _1279363;
*idx_1279343 = val_1279364;
__syncthreads();
l1279366: ;
bool _1279369;
_1279369 = tid_x_1279012 < 32;
if (_1279369) goto l1279370; else goto l1279429;
l1279429: ;
goto l1279428;
l1279370: ;
int _1279371;
_1279371 = blockDim_y_1279021 * blockIdx_y_1279024;
int _1279372;
_1279372 = threadIdx_y_1279018 + _1279371;
int _1279373;
_1279373 = _1279372 % 2;
bool _1279374;
_1279374 = _1279373 == 0;
if (_1279374) goto l1279375; else goto l1279427;
l1279427: ;
goto l1279428;
l1279428: ;
return ;
l1279375: ;
_1279378 = blockDim_x();
p_1279378 = _1279378;
l1279376: ;
_1279378 = p_1279378;
_1279381 = blockIdx_x();
p_1279381 = _1279381;
l1279379: ;
_1279381 = p_1279381;
_1279384 = blockDim_y();
p_1279384 = _1279384;
l1279382: ;
_1279384 = p_1279384;
_1279387 = blockIdx_y();
p_1279387 = _1279387;
l1279385: ;
_1279387 = p_1279387;
int _1279412;
_1279412 = _1018511_1279007.e3;
int _1279398;
_1279398 = 2 * tid_y_1279015;
int _1279399;
_1279399 = 1 + _1279398;
int _1279388;
_1279388 = 128 * tid_y_1279015;
int _1279415;
_1279415 = _1279378 * _1279381;
int _1279389;
_1279389 = 2 * tid_x_1279012;
int _1279416;
_1279416 = _1279415 / 2;
int _1279409;
_1279409 = _1279384 * _1279387;
int _1279400;
_1279400 = 64 * _1279399;
int _1279390;
_1279390 = _1279388 + _1279389;
int _1279401;
_1279401 = _1279400 + _1279389;
int _1279410;
_1279410 = _1279409 / 2;
float* idx_1279391;
idx_1279391 = spm_1279031 + _1279390;
int _1279394;
_1279394 = 1 + _1279390;
int _1279405;
_1279405 = 1 + _1279401;
float* idx_1279402;
idx_1279402 = spm_1279031 + _1279401;
int _1279411;
_1279411 = tid_y_1279015 + _1279410;
float _1279392;
_1279392 = *idx_1279391;
float* idx_1279395;
idx_1279395 = spm_1279031 + _1279394;
float* idx_1279406;
idx_1279406 = spm_1279031 + _1279405;
int _1279413;
_1279413 = _1279411 * _1279412;
float _1279419;
_1279419 = _1279392;
float _1279396;
_1279396 = *idx_1279395;
int _1279414;
_1279414 = _1279413 + tid_x_1279012;
float _1279420;
_1279420 = _1279396;
int _1279417;
_1279417 = _1279414 + _1279416;
float _1279421;
_1279421 = _1279419 + _1279420;
float _1279403;
_1279403 = *idx_1279402;
float* idx_1279418;
idx_1279418 = _1018508_1279004 + _1279417;
float _1279422;
_1279422 = _1279403;
float _1279407;
_1279407 = *idx_1279406;
float _1279423;
_1279423 = _1279421 + _1279422;
float _1279424;
_1279424 = _1279407;
float val_1279425;
val_1279425 = _1279423 + _1279424;
*idx_1279418 = val_1279425;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1015603(struct_Img_220118 _1015606_1276581, float* _1015607_1276582, struct_Img_220118 _1015608_1276583, float* _1015609_1276584, struct_Img_220118 _1015610_1276585, float* _1015611_1276586) {
int _1276589;
int p_1276589;
int _1276592;
int p_1276592;
int _1276595;
int p_1276595;
int _1276598;
int p_1276598;
int _1276601;
int p_1276601;
int _1276604;
int p_1276604;
int _1276607;
int p_1276607;
struct_BoundaryMode_220129 bh_lower_1276614;
struct_BoundaryMode_220129 pbh_lower_1276614;
float _1276629;
float p_1276629;
float _1276632;
float p_1276632;
struct_BoundaryMode_220129 bh_lower_1276638;
struct_BoundaryMode_220129 pbh_lower_1276638;
float _1276650;
float p_1276650;
float _1276653;
float p_1276653;
struct_BoundaryMode_220129 bh_lower_1276657;
struct_BoundaryMode_220129 pbh_lower_1276657;
float _1276669;
float p_1276669;
float _1276672;
float p_1276672;
struct_BoundaryMode_220129 bh_lower_1276676;
struct_BoundaryMode_220129 pbh_lower_1276676;
float _1276688;
float p_1276688;
float _1276691;
float p_1276691;
struct_BoundaryMode_220129 bh_lower_1276697;
struct_BoundaryMode_220129 pbh_lower_1276697;
float _1276709;
float p_1276709;
float _1276712;
float p_1276712;
_1276589 = threadIdx_x();
p_1276589 = _1276589;
l1276587: ;
_1276589 = p_1276589;
_1276592 = blockDim_x();
p_1276592 = _1276592;
l1276590: ;
_1276592 = p_1276592;
_1276595 = blockIdx_x();
p_1276595 = _1276595;
l1276593: ;
_1276595 = p_1276595;
_1276598 = threadIdx_y();
p_1276598 = _1276598;
l1276596: ;
_1276598 = p_1276598;
_1276601 = blockDim_y();
p_1276601 = _1276601;
l1276599: ;
_1276601 = p_1276601;
_1276604 = blockIdx_y();
p_1276604 = _1276604;
l1276602: ;
_1276604 = p_1276604;
_1276607 = blockDim_y();
p_1276607 = _1276607;
l1276605: ;
_1276607 = p_1276607;
int _1276608;
_1276608 = _1276601 * _1276604;
int gid_y_1276609;
gid_y_1276609 = _1276598 + _1276608;
union variant_220130 _1276752;
_1276752.qs32 = gid_y_1276609;
struct_BoundaryMode_220129 _1276753;
_1276753.e0 = 0;
_1276753.e1 = _1276752;
bool _1276610;
_1276610 = gid_y_1276609 < 0;
if (_1276610) goto l1276611; else goto l1276774;
l1276774: ;
pbh_lower_1276614 = _1276753;
goto l1276612;
l1276611: ;
union variant_220130 _1265919_8046;
_1265919_8046.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8048;
_1265920_8048.e0 = 1;
_1265920_8048.e1 = _1265919_8046;
pbh_lower_1276614 = _1265920_8048;
goto l1276612;
l1276612: ;
bh_lower_1276614 = pbh_lower_1276614;
int _1276620;
_1276620 = _1015610_1276585.e3;
union variant_220130 _1276618;
_1276618 = bh_lower_1276614.e1;
int _1276622;
_1276622 = _1276592 * _1276595;
int gid_x_1276623;
gid_x_1276623 = _1276589 + _1276622;
unsigned int _1276615;
_1276615 = bh_lower_1276614.e0;
bool _1276616;
_1276616 = _1276615 == 0;
if (_1276616) goto l1276617; else goto l1276769;
l1276769: ;
bool _1276770;
_1276770 = _1276615 == 1;
if (_1276770) goto l1276771; else goto l1276773;
l1276773: ;
// bottom: float r4_1265918_8057;
// bottom: p_1276632 = r4_1265918_8057;
goto l1276630;
l1276771: ;
float c_1276772;
c_1276772 = _1276618.pf32;
p_1276632 = c_1276772;
goto l1276630;
l1276617: ;
int y_1276619;
y_1276619 = _1276618.qs32;
int _1276621;
_1276621 = y_1276619 * _1276620;
int _1276624;
_1276624 = _1276621 + gid_x_1276623;
int _1276625;
_1276625 = 128 + _1276624;
float* idx_1276626;
idx_1276626 = _1015609_1276584 + _1276625;
_1276629 = __ldg(idx_1276626);
p_1276629 = _1276629;
l1276627: ;
_1276629 = p_1276629;
p_1276632 = _1276629;
goto l1276630;
l1276630: ;
_1276632 = p_1276632;
int _1276633;
_1276633 = -1 + gid_y_1276609;
int _1276719;
_1276719 = _1015606_1276581.e3;
bool _1276634;
_1276634 = _1276633 < 0;
int _1276720;
_1276720 = gid_y_1276609 * _1276719;
int _1276721;
_1276721 = _1276720 + gid_x_1276623;
int _1276722;
_1276722 = 128 + _1276721;
float* idx_1276723;
idx_1276723 = _1015611_1276586 + _1276722;
float _1276724;
_1276724 = *idx_1276723;
if (_1276634) goto l1276635; else goto l1276766;
l1276766: ;
union variant_220130 _1276767;
_1276767.qs32 = _1276633;
struct_BoundaryMode_220129 _1276768;
_1276768.e0 = 0;
_1276768.e1 = _1276767;
pbh_lower_1276638 = _1276768;
goto l1276636;
l1276635: ;
union variant_220130 _1265919_8066;
_1265919_8066.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8068;
_1265920_8068.e0 = 1;
_1265920_8068.e1 = _1265919_8066;
pbh_lower_1276638 = _1265920_8068;
goto l1276636;
l1276636: ;
bh_lower_1276638 = pbh_lower_1276638;
union variant_220130 _1276642;
_1276642 = bh_lower_1276638.e1;
unsigned int _1276639;
_1276639 = bh_lower_1276638.e0;
bool _1276640;
_1276640 = _1276639 == 0;
if (_1276640) goto l1276641; else goto l1276760;
l1276760: ;
bool _1276761;
_1276761 = _1276639 == 1;
if (_1276761) goto l1276762; else goto l1276764;
l1276764: ;
// bottom: float r4_1265918_8076;
// bottom: p_1276653 = r4_1265918_8076;
goto l1276651;
l1276762: ;
float c_1276763;
c_1276763 = _1276642.pf32;
p_1276653 = c_1276763;
goto l1276651;
l1276641: ;
int y_1276643;
y_1276643 = _1276642.qs32;
int _1276644;
_1276644 = y_1276643 * _1276620;
int _1276645;
_1276645 = _1276644 + gid_x_1276623;
int _1276646;
_1276646 = 128 + _1276645;
float* idx_1276647;
idx_1276647 = _1015609_1276584 + _1276646;
_1276650 = __ldg(idx_1276647);
p_1276650 = _1276650;
l1276648: ;
_1276650 = p_1276650;
p_1276653 = _1276650;
goto l1276651;
l1276651: ;
_1276653 = p_1276653;
if (_1276610) goto l1276654; else goto l1276759;
l1276759: ;
pbh_lower_1276657 = _1276753;
goto l1276655;
l1276654: ;
union variant_220130 _1265919_8078;
_1265919_8078.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8080;
_1265920_8080.e0 = 1;
_1265920_8080.e1 = _1265919_8078;
pbh_lower_1276657 = _1265920_8080;
goto l1276655;
l1276655: ;
bh_lower_1276657 = pbh_lower_1276657;
union variant_220130 _1276661;
_1276661 = bh_lower_1276657.e1;
unsigned int _1276658;
_1276658 = bh_lower_1276657.e0;
bool _1276659;
_1276659 = _1276658 == 0;
if (_1276659) goto l1276660; else goto l1276754;
l1276754: ;
bool _1276755;
_1276755 = _1276658 == 1;
if (_1276755) goto l1276756; else goto l1276758;
l1276758: ;
// bottom: float r4_1265918_8088;
// bottom: p_1276672 = r4_1265918_8088;
goto l1276670;
l1276756: ;
float c_1276757;
c_1276757 = _1276661.pf32;
p_1276672 = c_1276757;
goto l1276670;
l1276660: ;
int y_1276662;
y_1276662 = _1276661.qs32;
int _1276663;
_1276663 = y_1276662 * _1276620;
int _1276664;
_1276664 = _1276663 + gid_x_1276623;
int _1276665;
_1276665 = 127 + _1276664;
float* idx_1276666;
idx_1276666 = _1015609_1276584 + _1276665;
_1276669 = __ldg(idx_1276666);
p_1276669 = _1276669;
l1276667: ;
_1276669 = p_1276669;
p_1276672 = _1276669;
goto l1276670;
l1276670: ;
_1276672 = p_1276672;
if (_1276610) goto l1276673; else goto l1276751;
l1276751: ;
pbh_lower_1276676 = _1276753;
goto l1276674;
l1276673: ;
union variant_220130 _1265919_8090;
_1265919_8090.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8092;
_1265920_8092.e0 = 1;
_1265920_8092.e1 = _1265919_8090;
pbh_lower_1276676 = _1265920_8092;
goto l1276674;
l1276674: ;
bh_lower_1276676 = pbh_lower_1276676;
unsigned int _1276677;
_1276677 = bh_lower_1276676.e0;
bool _1276678;
_1276678 = _1276677 == 0;
union variant_220130 _1276680;
_1276680 = bh_lower_1276676.e1;
if (_1276678) goto l1276679; else goto l1276746;
l1276746: ;
bool _1276747;
_1276747 = _1276677 == 1;
if (_1276747) goto l1276748; else goto l1276750;
l1276750: ;
// bottom: float r4_1265918_8100;
// bottom: p_1276691 = r4_1265918_8100;
goto l1276689;
l1276748: ;
float c_1276749;
c_1276749 = _1276680.pf32;
p_1276691 = c_1276749;
goto l1276689;
l1276679: ;
int y_1276681;
y_1276681 = _1276680.qs32;
int _1276682;
_1276682 = y_1276681 * _1276620;
int _1276683;
_1276683 = _1276682 + gid_x_1276623;
int _1276684;
_1276684 = 129 + _1276683;
float* idx_1276685;
idx_1276685 = _1015609_1276584 + _1276684;
_1276688 = __ldg(idx_1276685);
p_1276688 = _1276688;
l1276686: ;
_1276688 = p_1276688;
p_1276691 = _1276688;
goto l1276689;
l1276689: ;
_1276691 = p_1276691;
int _1276692;
_1276692 = 1 + gid_y_1276609;
bool _1276693;
_1276693 = _1276692 < 0;
if (_1276693) goto l1276694; else goto l1276743;
l1276743: ;
union variant_220130 _1276744;
_1276744.qs32 = _1276692;
struct_BoundaryMode_220129 _1276745;
_1276745.e0 = 0;
_1276745.e1 = _1276744;
pbh_lower_1276697 = _1276745;
goto l1276695;
l1276694: ;
union variant_220130 _1265919_8107;
_1265919_8107.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8109;
_1265920_8109.e0 = 1;
_1265920_8109.e1 = _1265919_8107;
pbh_lower_1276697 = _1265920_8109;
goto l1276695;
l1276695: ;
bh_lower_1276697 = pbh_lower_1276697;
union variant_220130 _1276701;
_1276701 = bh_lower_1276697.e1;
unsigned int _1276698;
_1276698 = bh_lower_1276697.e0;
bool _1276699;
_1276699 = _1276698 == 0;
if (_1276699) goto l1276700; else goto l1276738;
l1276738: ;
bool _1276739;
_1276739 = _1276698 == 1;
if (_1276739) goto l1276740; else goto l1276742;
l1276742: ;
// bottom: float r4_1265918_8117;
// bottom: p_1276712 = r4_1265918_8117;
goto l1276710;
l1276740: ;
float c_1276741;
c_1276741 = _1276701.pf32;
p_1276712 = c_1276741;
goto l1276710;
l1276700: ;
int y_1276702;
y_1276702 = _1276701.qs32;
int _1276703;
_1276703 = y_1276702 * _1276620;
int _1276704;
_1276704 = _1276703 + gid_x_1276623;
int _1276705;
_1276705 = 128 + _1276704;
float* idx_1276706;
idx_1276706 = _1015609_1276584 + _1276705;
_1276709 = __ldg(idx_1276706);
p_1276709 = _1276709;
l1276707: ;
_1276709 = p_1276709;
p_1276712 = _1276709;
goto l1276710;
l1276710: ;
_1276712 = p_1276712;
float _1276728;
_1276728 = 2.500000e-01f * _1276653;
float _1276718;
_1276718 = 2.000000e-01f * _1276632;
int _1276713;
_1276713 = _1015608_1276583.e3;
float _1276730;
_1276730 = 2.500000e-01f * _1276672;
float _1276734;
_1276734 = 2.500000e-01f * _1276712;
float _1276729;
_1276729 = 0.000000e+00f + _1276728;
float _1276732;
_1276732 = 2.500000e-01f * _1276691;
float _1276725;
_1276725 = _1276724;
int _1276714;
_1276714 = gid_y_1276609 * _1276713;
float _1276731;
_1276731 = _1276729 + _1276730;
float _1276733;
_1276733 = _1276731 + _1276732;
float _1276726;
_1276726 = 2.000000e-01f * _1276725;
int _1276715;
_1276715 = _1276714 + gid_x_1276623;
float _1276735;
_1276735 = _1276733 + _1276734;
float _1276727;
_1276727 = _1276718 + _1276726;
int _1276716;
_1276716 = 128 + _1276715;
float val_1276736;
val_1276736 = _1276727 + _1276735;
float* idx_1276717;
idx_1276717 = _1015607_1276582 + _1276716;
*idx_1276717 = val_1276736;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_995956(float* _995959_1286995, float* _995960_1286996, int _995961_1286997) {
int _1287000;
int p_1287000;
int _1287003;
int p_1287003;
int _1287006;
int p_1287006;
int _1287009;
int p_1287009;
int _1287012;
int p_1287012;
int _1287015;
int p_1287015;
int _1287018;
int p_1287018;
int converge_1287024;
int pconverge_1287024;
int converge_1287031;
int pconverge_1287031;
float _1287037;
float p_1287037;
int converge_1287042;
int pconverge_1287042;
int converge_1287046;
int pconverge_1287046;
float _1287052;
float p_1287052;
int converge_1287055;
int pconverge_1287055;
int converge_1287058;
int pconverge_1287058;
float _1287064;
float p_1287064;
int converge_1287069;
int pconverge_1287069;
int converge_1287072;
int pconverge_1287072;
float _1287078;
float p_1287078;
int converge_1287081;
int pconverge_1287081;
int converge_1287086;
int pconverge_1287086;
float _1287092;
float p_1287092;
_1287000 = threadIdx_x();
p_1287000 = _1287000;
l1286998: ;
_1287000 = p_1287000;
_1287003 = blockDim_x();
p_1287003 = _1287003;
l1287001: ;
_1287003 = p_1287003;
_1287006 = blockIdx_x();
p_1287006 = _1287006;
l1287004: ;
_1287006 = p_1287006;
_1287009 = threadIdx_y();
p_1287009 = _1287009;
l1287007: ;
_1287009 = p_1287009;
_1287012 = blockDim_y();
p_1287012 = _1287012;
l1287010: ;
_1287012 = p_1287012;
_1287015 = blockIdx_y();
p_1287015 = _1287015;
l1287013: ;
_1287015 = p_1287015;
_1287018 = blockDim_y();
p_1287018 = _1287018;
l1287016: ;
_1287018 = p_1287018;
int _1287019;
_1287019 = _1287003 * _1287006;
int gid_x_1287020;
gid_x_1287020 = _1287000 + _1287019;
int _1287116;
_1287116 = 0 - gid_x_1287020;
bool _1287021;
_1287021 = gid_x_1287020 < 0;
int _1287117;
_1287117 = _1287116 - 1;
if (_1287021) goto l1287022; else goto l1287134;
l1287134: ;
pconverge_1287024 = gid_x_1287020;
goto l1287023;
l1287022: ;
pconverge_1287024 = _1287117;
goto l1287023;
l1287023: ;
converge_1287024 = pconverge_1287024;
int _1287025;
_1287025 = _1287012 * _1287015;
int gid_y_1287026;
gid_y_1287026 = _1287009 + _1287025;
int _1287027;
_1287027 = -1 + gid_y_1287026;
bool _1287028;
_1287028 = _1287027 < 0;
if (_1287028) goto l1287029; else goto l1287133;
l1287133: ;
pconverge_1287031 = _1287027;
goto l1287030;
l1287029: ;
int _1287131;
_1287131 = 0 - _1287027;
int _1287132;
_1287132 = _1287131 - 1;
pconverge_1287031 = _1287132;
goto l1287030;
l1287030: ;
converge_1287031 = pconverge_1287031;
int _1287032;
_1287032 = converge_1287031 * _995961_1286997;
int _1287033;
_1287033 = _1287032 + converge_1287024;
float* idx_1287034;
idx_1287034 = _995959_1286995 + _1287033;
_1287037 = __ldg(idx_1287034);
p_1287037 = _1287037;
l1287035: ;
_1287037 = p_1287037;
int _1287038;
_1287038 = -1 + gid_x_1287020;
bool _1287039;
_1287039 = _1287038 < 0;
if (_1287039) goto l1287040; else goto l1287130;
l1287130: ;
pconverge_1287042 = _1287038;
goto l1287041;
l1287040: ;
int _1287128;
_1287128 = 0 - _1287038;
int _1287129;
_1287129 = _1287128 - 1;
pconverge_1287042 = _1287129;
goto l1287041;
l1287041: ;
converge_1287042 = pconverge_1287042;
bool _1287043;
_1287043 = gid_y_1287026 < 0;
int _1287119;
_1287119 = 0 - gid_y_1287026;
int _1287120;
_1287120 = _1287119 - 1;
if (_1287043) goto l1287044; else goto l1287127;
l1287127: ;
pconverge_1287046 = gid_y_1287026;
goto l1287045;
l1287044: ;
pconverge_1287046 = _1287120;
goto l1287045;
l1287045: ;
converge_1287046 = pconverge_1287046;
int _1287047;
_1287047 = converge_1287046 * _995961_1286997;
int _1287048;
_1287048 = _1287047 + converge_1287042;
float* idx_1287049;
idx_1287049 = _995959_1286995 + _1287048;
_1287052 = __ldg(idx_1287049);
p_1287052 = _1287052;
l1287050: ;
_1287052 = p_1287052;
if (_1287021) goto l1287053; else goto l1287126;
l1287126: ;
pconverge_1287055 = gid_x_1287020;
goto l1287054;
l1287053: ;
pconverge_1287055 = _1287117;
goto l1287054;
l1287054: ;
converge_1287055 = pconverge_1287055;
if (_1287043) goto l1287056; else goto l1287125;
l1287125: ;
pconverge_1287058 = gid_y_1287026;
goto l1287057;
l1287056: ;
pconverge_1287058 = _1287120;
goto l1287057;
l1287057: ;
converge_1287058 = pconverge_1287058;
int _1287059;
_1287059 = converge_1287058 * _995961_1286997;
int _1287060;
_1287060 = _1287059 + converge_1287055;
float* idx_1287061;
idx_1287061 = _995959_1286995 + _1287060;
_1287064 = __ldg(idx_1287061);
p_1287064 = _1287064;
l1287062: ;
_1287064 = p_1287064;
int _1287065;
_1287065 = 1 + gid_x_1287020;
bool _1287066;
_1287066 = _1287065 < 0;
if (_1287066) goto l1287067; else goto l1287124;
l1287124: ;
pconverge_1287069 = _1287065;
goto l1287068;
l1287067: ;
int _1287122;
_1287122 = 0 - _1287065;
int _1287123;
_1287123 = _1287122 - 1;
pconverge_1287069 = _1287123;
goto l1287068;
l1287068: ;
converge_1287069 = pconverge_1287069;
if (_1287043) goto l1287070; else goto l1287121;
l1287121: ;
pconverge_1287072 = gid_y_1287026;
goto l1287071;
l1287070: ;
pconverge_1287072 = _1287120;
goto l1287071;
l1287071: ;
converge_1287072 = pconverge_1287072;
int _1287073;
_1287073 = converge_1287072 * _995961_1286997;
int _1287074;
_1287074 = _1287073 + converge_1287069;
float* idx_1287075;
idx_1287075 = _995959_1286995 + _1287074;
_1287078 = __ldg(idx_1287075);
p_1287078 = _1287078;
l1287076: ;
_1287078 = p_1287078;
if (_1287021) goto l1287079; else goto l1287118;
l1287118: ;
pconverge_1287081 = gid_x_1287020;
goto l1287080;
l1287079: ;
pconverge_1287081 = _1287117;
goto l1287080;
l1287080: ;
converge_1287081 = pconverge_1287081;
int _1287082;
_1287082 = 1 + gid_y_1287026;
bool _1287083;
_1287083 = _1287082 < 0;
if (_1287083) goto l1287084; else goto l1287115;
l1287115: ;
pconverge_1287086 = _1287082;
goto l1287085;
l1287084: ;
int _1287113;
_1287113 = 0 - _1287082;
int _1287114;
_1287114 = _1287113 - 1;
pconverge_1287086 = _1287114;
goto l1287085;
l1287085: ;
converge_1287086 = pconverge_1287086;
int _1287087;
_1287087 = converge_1287086 * _995961_1286997;
int _1287088;
_1287088 = _1287087 + converge_1287081;
float* idx_1287089;
idx_1287089 = _995959_1286995 + _1287088;
_1287092 = __ldg(idx_1287089);
p_1287092 = _1287092;
l1287090: ;
_1287092 = p_1287092;
int _1287093;
_1287093 = 4 * _995961_1286997;
float _1287106;
_1287106 = -4.000000e+00f * _1287064;
float _1287102;
_1287102 = 1.000000e+00f * _1287037;
float _1287104;
_1287104 = 1.000000e+00f * _1287052;
float _1287103;
_1287103 = 0.000000e+00f + _1287102;
int _1287094;
_1287094 = 64 + _1287093;
float _1287108;
_1287108 = 1.000000e+00f * _1287078;
int _1287095;
_1287095 = _1287094 - 1;
float _1287110;
_1287110 = 1.000000e+00f * _1287092;
float _1287105;
_1287105 = _1287103 + _1287104;
int _1287096;
_1287096 = _1287095 / 64;
float _1287107;
_1287107 = _1287105 + _1287106;
int _1287097;
_1287097 = 64 * _1287096;
float _1287109;
_1287109 = _1287107 + _1287108;
int stride_1287098;
stride_1287098 = _1287097 / 4;
float _1287111;
_1287111 = _1287109 + _1287110;
int _1287099;
_1287099 = gid_y_1287026 * stride_1287098;
int _1287100;
_1287100 = _1287099 + gid_x_1287020;
float* idx_1287101;
idx_1287101 = _995960_1286996 + _1287100;
*idx_1287101 = _1287111;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1044294(float* _1044297_1286146, struct_Img_220118 _1044298_1286147, struct_Img_220118 _1044299_1286148, float* _1044300_1286149, struct_Img_220118 _1044301_1286150, float* _1044302_1286151) {
int _1286154;
int p_1286154;
int _1286157;
int p_1286157;
int _1286160;
int p_1286160;
int _1286163;
int p_1286163;
int _1286166;
int p_1286166;
int _1286169;
int p_1286169;
int _1286172;
int p_1286172;
float _1286185;
float p_1286185;
float _1286199;
float p_1286199;
float _1286204;
float p_1286204;
float _1286209;
float p_1286209;
float _1286217;
float p_1286217;
_1286154 = threadIdx_x();
p_1286154 = _1286154;
l1286152: ;
_1286154 = p_1286154;
_1286157 = blockDim_x();
p_1286157 = _1286157;
l1286155: ;
_1286157 = p_1286157;
_1286160 = blockIdx_x();
p_1286160 = _1286160;
l1286158: ;
_1286160 = p_1286160;
_1286163 = threadIdx_y();
p_1286163 = _1286163;
l1286161: ;
_1286163 = p_1286163;
_1286166 = blockDim_y();
p_1286166 = _1286166;
l1286164: ;
_1286166 = p_1286166;
_1286169 = blockIdx_y();
p_1286169 = _1286169;
l1286167: ;
_1286169 = p_1286169;
_1286172 = blockDim_y();
p_1286172 = _1286172;
l1286170: ;
_1286172 = p_1286172;
int _1286173;
_1286173 = _1286166 * _1286169;
int _1286178;
_1286178 = _1286157 * _1286160;
int gid_y_1286174;
gid_y_1286174 = _1286163 + _1286173;
int _1286175;
_1286175 = 1 + gid_y_1286174;
int _1286176;
_1286176 = _1044298_1286147.e3;
int _1286177;
_1286177 = _1286175 * _1286176;
int gid_x_1286179;
gid_x_1286179 = _1286154 + _1286178;
int _1286180;
_1286180 = _1286177 + gid_x_1286179;
int _1286181;
_1286181 = 128 + _1286180;
float* idx_1286182;
idx_1286182 = _1044297_1286146 + _1286181;
_1286185 = __ldg(idx_1286182);
p_1286185 = _1286185;
l1286183: ;
_1286185 = p_1286185;
int _1286193;
_1286193 = gid_y_1286174 * _1286176;
int _1286186;
_1286186 = _1044299_1286148.e3;
int _1286194;
_1286194 = _1286193 + gid_x_1286179;
int _1286187;
_1286187 = _1286175 * _1286186;
int _1286195;
_1286195 = 128 + _1286194;
int _1286188;
_1286188 = _1286187 + gid_x_1286179;
float* idx_1286196;
idx_1286196 = _1044297_1286146 + _1286195;
int _1286189;
_1286189 = 128 + _1286188;
float* idx_1286190;
idx_1286190 = _1044302_1286151 + _1286189;
float _1286191;
_1286191 = *idx_1286190;
_1286199 = __ldg(idx_1286196);
p_1286199 = _1286199;
l1286197: ;
_1286199 = p_1286199;
int _1286200;
_1286200 = 127 + _1286180;
float* idx_1286201;
idx_1286201 = _1044297_1286146 + _1286200;
_1286204 = __ldg(idx_1286201);
p_1286204 = _1286204;
l1286202: ;
_1286204 = p_1286204;
int _1286205;
_1286205 = 129 + _1286180;
float* idx_1286206;
idx_1286206 = _1044297_1286146 + _1286205;
_1286209 = __ldg(idx_1286206);
p_1286209 = _1286209;
l1286207: ;
_1286209 = p_1286209;
int _1286210;
_1286210 = 2 + gid_y_1286174;
int _1286211;
_1286211 = _1286210 * _1286176;
int _1286212;
_1286212 = _1286211 + gid_x_1286179;
int _1286213;
_1286213 = 128 + _1286212;
float* idx_1286214;
idx_1286214 = _1044297_1286146 + _1286213;
_1286217 = __ldg(idx_1286214);
p_1286217 = _1286217;
l1286215: ;
_1286217 = p_1286217;
float _1286227;
_1286227 = 2.500000e-01f * _1286199;
float _1286223;
_1286223 = 2.000000e-01f * _1286185;
int _1286218;
_1286218 = _1044301_1286150.e3;
float _1286233;
_1286233 = 2.500000e-01f * _1286217;
float _1286224;
_1286224 = _1286191;
float _1286229;
_1286229 = 2.500000e-01f * _1286204;
float _1286231;
_1286231 = 2.500000e-01f * _1286209;
float _1286228;
_1286228 = 0.000000e+00f + _1286227;
int _1286219;
_1286219 = _1286175 * _1286218;
float _1286225;
_1286225 = 2.000000e-01f * _1286224;
float _1286230;
_1286230 = _1286228 + _1286229;
float _1286232;
_1286232 = _1286230 + _1286231;
int _1286220;
_1286220 = _1286219 + gid_x_1286179;
float _1286226;
_1286226 = _1286223 + _1286225;
float _1286234;
_1286234 = _1286232 + _1286233;
int _1286221;
_1286221 = 128 + _1286220;
float val_1286235;
val_1286235 = _1286226 + _1286234;
float* idx_1286222;
idx_1286222 = _1044300_1286149 + _1286221;
*idx_1286222 = val_1286235;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1035424(float* _1035427_1271071, struct_Img_220118 _1035428_1271072, float* _1035429_1271073, struct_Img_220118 _1035430_1271074, struct_Img_220118 _1035431_1271075, float* _1035432_1271076) {
int _1271079;
int p_1271079;
int _1271082;
int p_1271082;
int _1271085;
int p_1271085;
int _1271088;
int p_1271088;
int _1271091;
int p_1271091;
int _1271094;
int p_1271094;
int _1271097;
int p_1271097;
struct_BoundaryMode_220129 bh_upper_1271108;
struct_BoundaryMode_220129 pbh_upper_1271108;
float _1271123;
float p_1271123;
float _1271126;
float p_1271126;
struct_BoundaryMode_220129 bh_upper_1271132;
struct_BoundaryMode_220129 pbh_upper_1271132;
float _1271144;
float p_1271144;
float _1271147;
float p_1271147;
struct_BoundaryMode_220129 bh_upper_1271151;
struct_BoundaryMode_220129 pbh_upper_1271151;
float _1271163;
float p_1271163;
float _1271166;
float p_1271166;
struct_BoundaryMode_220129 bh_upper_1271170;
struct_BoundaryMode_220129 pbh_upper_1271170;
float _1271182;
float p_1271182;
float _1271185;
float p_1271185;
struct_BoundaryMode_220129 bh_upper_1271191;
struct_BoundaryMode_220129 pbh_upper_1271191;
float _1271203;
float p_1271203;
float _1271206;
float p_1271206;
_1271079 = threadIdx_x();
p_1271079 = _1271079;
l1271077: ;
_1271079 = p_1271079;
_1271082 = blockDim_x();
p_1271082 = _1271082;
l1271080: ;
_1271082 = p_1271082;
_1271085 = blockIdx_x();
p_1271085 = _1271085;
l1271083: ;
_1271085 = p_1271085;
_1271088 = threadIdx_y();
p_1271088 = _1271088;
l1271086: ;
_1271088 = p_1271088;
_1271091 = blockDim_y();
p_1271091 = _1271091;
l1271089: ;
_1271091 = p_1271091;
_1271094 = blockIdx_y();
p_1271094 = _1271094;
l1271092: ;
_1271094 = p_1271094;
_1271097 = blockDim_y();
p_1271097 = _1271097;
l1271095: ;
_1271097 = p_1271097;
int _1271098;
_1271098 = _1035430_1271074.e2;
int _1271102;
_1271102 = _1271091 * _1271094;
int _1271099;
_1271099 = _1035431_1271075.e2;
int _1271100;
_1271100 = _1271099 - 1;
int _1271101;
_1271101 = _1271100 + _1271088;
int gid_y_1271103;
gid_y_1271103 = _1271101 + _1271102;
bool _1271104;
_1271104 = _1271098 <= gid_y_1271103;
union variant_220130 _1271246;
_1271246.qs32 = gid_y_1271103;
struct_BoundaryMode_220129 _1271247;
_1271247.e0 = 0;
_1271247.e1 = _1271246;
if (_1271104) goto l1271105; else goto l1271268;
l1271268: ;
pbh_upper_1271108 = _1271247;
goto l1271106;
l1271105: ;
union variant_220130 _1265919_8187;
_1265919_8187.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8189;
_1265920_8189.e0 = 1;
_1265920_8189.e1 = _1265919_8187;
pbh_upper_1271108 = _1265920_8189;
goto l1271106;
l1271106: ;
bh_upper_1271108 = pbh_upper_1271108;
unsigned int _1271109;
_1271109 = bh_upper_1271108.e0;
int _1271114;
_1271114 = _1035430_1271074.e3;
union variant_220130 _1271112;
_1271112 = bh_upper_1271108.e1;
int _1271116;
_1271116 = _1271082 * _1271085;
bool _1271110;
_1271110 = _1271109 == 0;
int gid_x_1271117;
gid_x_1271117 = _1271079 + _1271116;
if (_1271110) goto l1271111; else goto l1271263;
l1271263: ;
bool _1271264;
_1271264 = _1271109 == 1;
if (_1271264) goto l1271265; else goto l1271267;
l1271267: ;
// bottom: float r4_1265918_8198;
// bottom: p_1271126 = r4_1265918_8198;
goto l1271124;
l1271265: ;
float c_1271266;
c_1271266 = _1271112.pf32;
p_1271126 = c_1271266;
goto l1271124;
l1271111: ;
int y_1271113;
y_1271113 = _1271112.qs32;
int _1271115;
_1271115 = y_1271113 * _1271114;
int _1271118;
_1271118 = _1271115 + gid_x_1271117;
int _1271119;
_1271119 = 128 + _1271118;
float* idx_1271120;
idx_1271120 = _1035429_1271073 + _1271119;
_1271123 = __ldg(idx_1271120);
p_1271123 = _1271123;
l1271121: ;
_1271123 = p_1271123;
p_1271126 = _1271123;
goto l1271124;
l1271124: ;
_1271126 = p_1271126;
int _1271213;
_1271213 = _1035428_1271072.e3;
int _1271127;
_1271127 = -1 + gid_y_1271103;
int _1271214;
_1271214 = gid_y_1271103 * _1271213;
bool _1271128;
_1271128 = _1271098 <= _1271127;
int _1271215;
_1271215 = _1271214 + gid_x_1271117;
int _1271216;
_1271216 = 128 + _1271215;
float* idx_1271217;
idx_1271217 = _1035432_1271076 + _1271216;
float _1271218;
_1271218 = *idx_1271217;
if (_1271128) goto l1271129; else goto l1271260;
l1271260: ;
union variant_220130 _1271261;
_1271261.qs32 = _1271127;
struct_BoundaryMode_220129 _1271262;
_1271262.e0 = 0;
_1271262.e1 = _1271261;
pbh_upper_1271132 = _1271262;
goto l1271130;
l1271129: ;
union variant_220130 _1265919_8206;
_1265919_8206.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8208;
_1265920_8208.e0 = 1;
_1265920_8208.e1 = _1265919_8206;
pbh_upper_1271132 = _1265920_8208;
goto l1271130;
l1271130: ;
bh_upper_1271132 = pbh_upper_1271132;
unsigned int _1271133;
_1271133 = bh_upper_1271132.e0;
union variant_220130 _1271136;
_1271136 = bh_upper_1271132.e1;
bool _1271134;
_1271134 = _1271133 == 0;
if (_1271134) goto l1271135; else goto l1271254;
l1271254: ;
bool _1271255;
_1271255 = _1271133 == 1;
if (_1271255) goto l1271256; else goto l1271258;
l1271258: ;
// bottom: float r4_1265918_8216;
// bottom: p_1271147 = r4_1265918_8216;
goto l1271145;
l1271256: ;
float c_1271257;
c_1271257 = _1271136.pf32;
p_1271147 = c_1271257;
goto l1271145;
l1271135: ;
int y_1271137;
y_1271137 = _1271136.qs32;
int _1271138;
_1271138 = y_1271137 * _1271114;
int _1271139;
_1271139 = _1271138 + gid_x_1271117;
int _1271140;
_1271140 = 128 + _1271139;
float* idx_1271141;
idx_1271141 = _1035429_1271073 + _1271140;
_1271144 = __ldg(idx_1271141);
p_1271144 = _1271144;
l1271142: ;
_1271144 = p_1271144;
p_1271147 = _1271144;
goto l1271145;
l1271145: ;
_1271147 = p_1271147;
if (_1271104) goto l1271148; else goto l1271253;
l1271253: ;
pbh_upper_1271151 = _1271247;
goto l1271149;
l1271148: ;
union variant_220130 _1265919_8218;
_1265919_8218.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8220;
_1265920_8220.e0 = 1;
_1265920_8220.e1 = _1265919_8218;
pbh_upper_1271151 = _1265920_8220;
goto l1271149;
l1271149: ;
bh_upper_1271151 = pbh_upper_1271151;
union variant_220130 _1271155;
_1271155 = bh_upper_1271151.e1;
unsigned int _1271152;
_1271152 = bh_upper_1271151.e0;
bool _1271153;
_1271153 = _1271152 == 0;
if (_1271153) goto l1271154; else goto l1271248;
l1271248: ;
bool _1271249;
_1271249 = _1271152 == 1;
if (_1271249) goto l1271250; else goto l1271252;
l1271252: ;
// bottom: float r4_1265918_8228;
// bottom: p_1271166 = r4_1265918_8228;
goto l1271164;
l1271250: ;
float c_1271251;
c_1271251 = _1271155.pf32;
p_1271166 = c_1271251;
goto l1271164;
l1271154: ;
int y_1271156;
y_1271156 = _1271155.qs32;
int _1271157;
_1271157 = y_1271156 * _1271114;
int _1271158;
_1271158 = _1271157 + gid_x_1271117;
int _1271159;
_1271159 = 127 + _1271158;
float* idx_1271160;
idx_1271160 = _1035429_1271073 + _1271159;
_1271163 = __ldg(idx_1271160);
p_1271163 = _1271163;
l1271161: ;
_1271163 = p_1271163;
p_1271166 = _1271163;
goto l1271164;
l1271164: ;
_1271166 = p_1271166;
if (_1271104) goto l1271167; else goto l1271245;
l1271245: ;
pbh_upper_1271170 = _1271247;
goto l1271168;
l1271167: ;
union variant_220130 _1265919_8230;
_1265919_8230.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8232;
_1265920_8232.e0 = 1;
_1265920_8232.e1 = _1265919_8230;
pbh_upper_1271170 = _1265920_8232;
goto l1271168;
l1271168: ;
bh_upper_1271170 = pbh_upper_1271170;
union variant_220130 _1271174;
_1271174 = bh_upper_1271170.e1;
unsigned int _1271171;
_1271171 = bh_upper_1271170.e0;
bool _1271172;
_1271172 = _1271171 == 0;
if (_1271172) goto l1271173; else goto l1271240;
l1271240: ;
bool _1271241;
_1271241 = _1271171 == 1;
if (_1271241) goto l1271242; else goto l1271244;
l1271244: ;
// bottom: float r4_1265918_8240;
// bottom: p_1271185 = r4_1265918_8240;
goto l1271183;
l1271242: ;
float c_1271243;
c_1271243 = _1271174.pf32;
p_1271185 = c_1271243;
goto l1271183;
l1271173: ;
int y_1271175;
y_1271175 = _1271174.qs32;
int _1271176;
_1271176 = y_1271175 * _1271114;
int _1271177;
_1271177 = _1271176 + gid_x_1271117;
int _1271178;
_1271178 = 129 + _1271177;
float* idx_1271179;
idx_1271179 = _1035429_1271073 + _1271178;
_1271182 = __ldg(idx_1271179);
p_1271182 = _1271182;
l1271180: ;
_1271182 = p_1271182;
p_1271185 = _1271182;
goto l1271183;
l1271183: ;
_1271185 = p_1271185;
int _1271186;
_1271186 = 1 + gid_y_1271103;
bool _1271187;
_1271187 = _1271098 <= _1271186;
if (_1271187) goto l1271188; else goto l1271237;
l1271237: ;
union variant_220130 _1271238;
_1271238.qs32 = _1271186;
struct_BoundaryMode_220129 _1271239;
_1271239.e0 = 0;
_1271239.e1 = _1271238;
pbh_upper_1271191 = _1271239;
goto l1271189;
l1271188: ;
union variant_220130 _1265919_8246;
_1265919_8246.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8248;
_1265920_8248.e0 = 1;
_1265920_8248.e1 = _1265919_8246;
pbh_upper_1271191 = _1265920_8248;
goto l1271189;
l1271189: ;
bh_upper_1271191 = pbh_upper_1271191;
union variant_220130 _1271195;
_1271195 = bh_upper_1271191.e1;
unsigned int _1271192;
_1271192 = bh_upper_1271191.e0;
bool _1271193;
_1271193 = _1271192 == 0;
if (_1271193) goto l1271194; else goto l1271232;
l1271232: ;
bool _1271233;
_1271233 = _1271192 == 1;
if (_1271233) goto l1271234; else goto l1271236;
l1271236: ;
// bottom: float r4_1265918_8256;
// bottom: p_1271206 = r4_1265918_8256;
goto l1271204;
l1271234: ;
float c_1271235;
c_1271235 = _1271195.pf32;
p_1271206 = c_1271235;
goto l1271204;
l1271194: ;
int y_1271196;
y_1271196 = _1271195.qs32;
int _1271197;
_1271197 = y_1271196 * _1271114;
int _1271198;
_1271198 = _1271197 + gid_x_1271117;
int _1271199;
_1271199 = 128 + _1271198;
float* idx_1271200;
idx_1271200 = _1035429_1271073 + _1271199;
_1271203 = __ldg(idx_1271200);
p_1271203 = _1271203;
l1271201: ;
_1271203 = p_1271203;
p_1271206 = _1271203;
goto l1271204;
l1271204: ;
_1271206 = p_1271206;
float _1271219;
_1271219 = _1271218;
float _1271228;
_1271228 = 2.500000e-01f * _1271206;
int _1271207;
_1271207 = _1035431_1271075.e3;
float _1271224;
_1271224 = 2.500000e-01f * _1271166;
float _1271212;
_1271212 = 2.000000e-01f * _1271126;
float _1271222;
_1271222 = 2.500000e-01f * _1271147;
float _1271226;
_1271226 = 2.500000e-01f * _1271185;
float _1271223;
_1271223 = 0.000000e+00f + _1271222;
float _1271220;
_1271220 = 2.000000e-01f * _1271219;
float _1271225;
_1271225 = _1271223 + _1271224;
int _1271208;
_1271208 = gid_y_1271103 * _1271207;
float _1271221;
_1271221 = _1271212 + _1271220;
float _1271227;
_1271227 = _1271225 + _1271226;
int _1271209;
_1271209 = _1271208 + gid_x_1271117;
float _1271229;
_1271229 = _1271227 + _1271228;
int _1271210;
_1271210 = 128 + _1271209;
float val_1271230;
val_1271230 = _1271221 + _1271229;
float* idx_1271211;
idx_1271211 = _1035427_1271071 + _1271210;
*idx_1271211 = val_1271230;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1030984(struct_Img_220118 _1030987_1285666, float* _1030988_1285667, float* _1030989_1285668, struct_Img_220118 _1030990_1285669, struct_Img_220118 _1030991_1285670, float* _1030992_1285671) {
int _1285674;
int p_1285674;
int _1285677;
int p_1285677;
int _1285680;
int p_1285680;
int _1285683;
int p_1285683;
int _1285686;
int p_1285686;
int _1285689;
int p_1285689;
int _1285692;
int p_1285692;
struct_BoundaryMode_220129 bh_upper_1285703;
struct_BoundaryMode_220129 pbh_upper_1285703;
float _1285718;
float p_1285718;
float _1285721;
float p_1285721;
struct_BoundaryMode_220129 bh_upper_1285727;
struct_BoundaryMode_220129 pbh_upper_1285727;
float _1285739;
float p_1285739;
float _1285742;
float p_1285742;
struct_BoundaryMode_220129 bh_upper_1285746;
struct_BoundaryMode_220129 pbh_upper_1285746;
float _1285758;
float p_1285758;
float _1285761;
float p_1285761;
struct_BoundaryMode_220129 bh_upper_1285765;
struct_BoundaryMode_220129 pbh_upper_1285765;
float _1285777;
float p_1285777;
float _1285780;
float p_1285780;
struct_BoundaryMode_220129 bh_upper_1285786;
struct_BoundaryMode_220129 pbh_upper_1285786;
float _1285798;
float p_1285798;
float _1285801;
float p_1285801;
_1285674 = threadIdx_x();
p_1285674 = _1285674;
l1285672: ;
_1285674 = p_1285674;
_1285677 = blockDim_x();
p_1285677 = _1285677;
l1285675: ;
_1285677 = p_1285677;
_1285680 = blockIdx_x();
p_1285680 = _1285680;
l1285678: ;
_1285680 = p_1285680;
_1285683 = threadIdx_y();
p_1285683 = _1285683;
l1285681: ;
_1285683 = p_1285683;
_1285686 = blockDim_y();
p_1285686 = _1285686;
l1285684: ;
_1285686 = p_1285686;
_1285689 = blockIdx_y();
p_1285689 = _1285689;
l1285687: ;
_1285689 = p_1285689;
_1285692 = blockDim_y();
p_1285692 = _1285692;
l1285690: ;
_1285692 = p_1285692;
int _1285694;
_1285694 = _1030991_1285670.e2;
int _1285695;
_1285695 = _1285694 - 1;
int _1285696;
_1285696 = _1285695 + _1285683;
int _1285697;
_1285697 = _1285686 * _1285689;
int _1285693;
_1285693 = _1030990_1285669.e2;
int gid_y_1285698;
gid_y_1285698 = _1285696 + _1285697;
bool _1285699;
_1285699 = _1285693 <= gid_y_1285698;
union variant_220130 _1285841;
_1285841.qs32 = gid_y_1285698;
struct_BoundaryMode_220129 _1285842;
_1285842.e0 = 0;
_1285842.e1 = _1285841;
if (_1285699) goto l1285700; else goto l1285863;
l1285863: ;
pbh_upper_1285703 = _1285842;
goto l1285701;
l1285700: ;
union variant_220130 _1265919_8273;
_1265919_8273.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8275;
_1265920_8275.e0 = 1;
_1265920_8275.e1 = _1265919_8273;
pbh_upper_1285703 = _1265920_8275;
goto l1285701;
l1285701: ;
bh_upper_1285703 = pbh_upper_1285703;
int _1285711;
_1285711 = _1285677 * _1285680;
unsigned int _1285704;
_1285704 = bh_upper_1285703.e0;
union variant_220130 _1285707;
_1285707 = bh_upper_1285703.e1;
int _1285709;
_1285709 = _1030990_1285669.e3;
int gid_x_1285712;
gid_x_1285712 = _1285674 + _1285711;
bool _1285705;
_1285705 = _1285704 == 0;
if (_1285705) goto l1285706; else goto l1285858;
l1285858: ;
bool _1285859;
_1285859 = _1285704 == 1;
if (_1285859) goto l1285860; else goto l1285862;
l1285862: ;
// bottom: float r4_1265918_8284;
// bottom: p_1285721 = r4_1265918_8284;
goto l1285719;
l1285860: ;
float c_1285861;
c_1285861 = _1285707.pf32;
p_1285721 = c_1285861;
goto l1285719;
l1285706: ;
int y_1285708;
y_1285708 = _1285707.qs32;
int _1285710;
_1285710 = y_1285708 * _1285709;
int _1285713;
_1285713 = _1285710 + gid_x_1285712;
int _1285714;
_1285714 = 128 + _1285713;
float* idx_1285715;
idx_1285715 = _1030989_1285668 + _1285714;
_1285718 = __ldg(idx_1285715);
p_1285718 = _1285718;
l1285716: ;
_1285718 = p_1285718;
p_1285721 = _1285718;
goto l1285719;
l1285719: ;
_1285721 = p_1285721;
int _1285808;
_1285808 = _1030987_1285666.e3;
int _1285722;
_1285722 = -1 + gid_y_1285698;
int _1285809;
_1285809 = gid_y_1285698 * _1285808;
bool _1285723;
_1285723 = _1285693 <= _1285722;
int _1285810;
_1285810 = _1285809 + gid_x_1285712;
int _1285811;
_1285811 = 128 + _1285810;
float* idx_1285812;
idx_1285812 = _1030992_1285671 + _1285811;
float _1285813;
_1285813 = *idx_1285812;
if (_1285723) goto l1285724; else goto l1285855;
l1285855: ;
union variant_220130 _1285856;
_1285856.qs32 = _1285722;
struct_BoundaryMode_220129 _1285857;
_1285857.e0 = 0;
_1285857.e1 = _1285856;
pbh_upper_1285727 = _1285857;
goto l1285725;
l1285724: ;
union variant_220130 _1265919_8292;
_1265919_8292.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8294;
_1265920_8294.e0 = 1;
_1265920_8294.e1 = _1265919_8292;
pbh_upper_1285727 = _1265920_8294;
goto l1285725;
l1285725: ;
bh_upper_1285727 = pbh_upper_1285727;
union variant_220130 _1285731;
_1285731 = bh_upper_1285727.e1;
unsigned int _1285728;
_1285728 = bh_upper_1285727.e0;
bool _1285729;
_1285729 = _1285728 == 0;
if (_1285729) goto l1285730; else goto l1285849;
l1285849: ;
bool _1285850;
_1285850 = _1285728 == 1;
if (_1285850) goto l1285851; else goto l1285853;
l1285853: ;
// bottom: float r4_1265918_8302;
// bottom: p_1285742 = r4_1265918_8302;
goto l1285740;
l1285851: ;
float c_1285852;
c_1285852 = _1285731.pf32;
p_1285742 = c_1285852;
goto l1285740;
l1285730: ;
int y_1285732;
y_1285732 = _1285731.qs32;
int _1285733;
_1285733 = y_1285732 * _1285709;
int _1285734;
_1285734 = _1285733 + gid_x_1285712;
int _1285735;
_1285735 = 128 + _1285734;
float* idx_1285736;
idx_1285736 = _1030989_1285668 + _1285735;
_1285739 = __ldg(idx_1285736);
p_1285739 = _1285739;
l1285737: ;
_1285739 = p_1285739;
p_1285742 = _1285739;
goto l1285740;
l1285740: ;
_1285742 = p_1285742;
if (_1285699) goto l1285743; else goto l1285848;
l1285848: ;
pbh_upper_1285746 = _1285842;
goto l1285744;
l1285743: ;
union variant_220130 _1265919_8304;
_1265919_8304.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8306;
_1265920_8306.e0 = 1;
_1265920_8306.e1 = _1265919_8304;
pbh_upper_1285746 = _1265920_8306;
goto l1285744;
l1285744: ;
bh_upper_1285746 = pbh_upper_1285746;
unsigned int _1285747;
_1285747 = bh_upper_1285746.e0;
bool _1285748;
_1285748 = _1285747 == 0;
union variant_220130 _1285750;
_1285750 = bh_upper_1285746.e1;
if (_1285748) goto l1285749; else goto l1285843;
l1285843: ;
bool _1285844;
_1285844 = _1285747 == 1;
if (_1285844) goto l1285845; else goto l1285847;
l1285847: ;
// bottom: float r4_1265918_8314;
// bottom: p_1285761 = r4_1265918_8314;
goto l1285759;
l1285845: ;
float c_1285846;
c_1285846 = _1285750.pf32;
p_1285761 = c_1285846;
goto l1285759;
l1285749: ;
int y_1285751;
y_1285751 = _1285750.qs32;
int _1285752;
_1285752 = y_1285751 * _1285709;
int _1285753;
_1285753 = _1285752 + gid_x_1285712;
int _1285754;
_1285754 = 127 + _1285753;
float* idx_1285755;
idx_1285755 = _1030989_1285668 + _1285754;
_1285758 = __ldg(idx_1285755);
p_1285758 = _1285758;
l1285756: ;
_1285758 = p_1285758;
p_1285761 = _1285758;
goto l1285759;
l1285759: ;
_1285761 = p_1285761;
if (_1285699) goto l1285762; else goto l1285840;
l1285840: ;
pbh_upper_1285765 = _1285842;
goto l1285763;
l1285762: ;
union variant_220130 _1265919_8316;
_1265919_8316.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8318;
_1265920_8318.e0 = 1;
_1265920_8318.e1 = _1265919_8316;
pbh_upper_1285765 = _1265920_8318;
goto l1285763;
l1285763: ;
bh_upper_1285765 = pbh_upper_1285765;
union variant_220130 _1285769;
_1285769 = bh_upper_1285765.e1;
unsigned int _1285766;
_1285766 = bh_upper_1285765.e0;
bool _1285767;
_1285767 = _1285766 == 0;
if (_1285767) goto l1285768; else goto l1285835;
l1285835: ;
bool _1285836;
_1285836 = _1285766 == 1;
if (_1285836) goto l1285837; else goto l1285839;
l1285839: ;
// bottom: float r4_1265918_8326;
// bottom: p_1285780 = r4_1265918_8326;
goto l1285778;
l1285837: ;
float c_1285838;
c_1285838 = _1285769.pf32;
p_1285780 = c_1285838;
goto l1285778;
l1285768: ;
int y_1285770;
y_1285770 = _1285769.qs32;
int _1285771;
_1285771 = y_1285770 * _1285709;
int _1285772;
_1285772 = _1285771 + gid_x_1285712;
int _1285773;
_1285773 = 129 + _1285772;
float* idx_1285774;
idx_1285774 = _1030989_1285668 + _1285773;
_1285777 = __ldg(idx_1285774);
p_1285777 = _1285777;
l1285775: ;
_1285777 = p_1285777;
p_1285780 = _1285777;
goto l1285778;
l1285778: ;
_1285780 = p_1285780;
int _1285781;
_1285781 = 1 + gid_y_1285698;
bool _1285782;
_1285782 = _1285693 <= _1285781;
if (_1285782) goto l1285783; else goto l1285832;
l1285832: ;
union variant_220130 _1285833;
_1285833.qs32 = _1285781;
struct_BoundaryMode_220129 _1285834;
_1285834.e0 = 0;
_1285834.e1 = _1285833;
pbh_upper_1285786 = _1285834;
goto l1285784;
l1285783: ;
union variant_220130 _1265919_8332;
_1265919_8332.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8334;
_1265920_8334.e0 = 1;
_1265920_8334.e1 = _1265919_8332;
pbh_upper_1285786 = _1265920_8334;
goto l1285784;
l1285784: ;
bh_upper_1285786 = pbh_upper_1285786;
union variant_220130 _1285790;
_1285790 = bh_upper_1285786.e1;
unsigned int _1285787;
_1285787 = bh_upper_1285786.e0;
bool _1285788;
_1285788 = _1285787 == 0;
if (_1285788) goto l1285789; else goto l1285827;
l1285827: ;
bool _1285828;
_1285828 = _1285787 == 1;
if (_1285828) goto l1285829; else goto l1285831;
l1285831: ;
// bottom: float r4_1265918_8342;
// bottom: p_1285801 = r4_1265918_8342;
goto l1285799;
l1285829: ;
float c_1285830;
c_1285830 = _1285790.pf32;
p_1285801 = c_1285830;
goto l1285799;
l1285789: ;
int y_1285791;
y_1285791 = _1285790.qs32;
int _1285792;
_1285792 = y_1285791 * _1285709;
int _1285793;
_1285793 = _1285792 + gid_x_1285712;
int _1285794;
_1285794 = 128 + _1285793;
float* idx_1285795;
idx_1285795 = _1030989_1285668 + _1285794;
_1285798 = __ldg(idx_1285795);
p_1285798 = _1285798;
l1285796: ;
_1285798 = p_1285798;
p_1285801 = _1285798;
goto l1285799;
l1285799: ;
_1285801 = p_1285801;
float _1285819;
_1285819 = 2.500000e-01f * _1285761;
float _1285814;
_1285814 = _1285813;
float _1285823;
_1285823 = 2.500000e-01f * _1285801;
float _1285821;
_1285821 = 2.500000e-01f * _1285780;
int _1285802;
_1285802 = _1030991_1285670.e3;
float _1285817;
_1285817 = 2.500000e-01f * _1285742;
int _1285803;
_1285803 = gid_y_1285698 * _1285802;
float _1285818;
_1285818 = 0.000000e+00f + _1285817;
float _1285807;
_1285807 = 2.000000e-01f * _1285721;
float _1285820;
_1285820 = _1285818 + _1285819;
float _1285815;
_1285815 = 2.000000e-01f * _1285814;
float _1285822;
_1285822 = _1285820 + _1285821;
int _1285804;
_1285804 = _1285803 + gid_x_1285712;
float _1285816;
_1285816 = _1285807 + _1285815;
float _1285824;
_1285824 = _1285822 + _1285823;
int _1285805;
_1285805 = 128 + _1285804;
float val_1285825;
val_1285825 = _1285816 + _1285824;
float* idx_1285806;
idx_1285806 = _1030988_1285667 + _1285805;
*idx_1285806 = val_1285825;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1015057(struct_Img_220118 _1015060_1287413, float* _1015061_1287414, struct_Img_220118 _1015062_1287415, float* _1015063_1287416, struct_Img_220118 _1015064_1287417, float* _1015065_1287418) {
int _1287421;
int p_1287421;
int _1287424;
int p_1287424;
int _1287427;
int p_1287427;
int _1287430;
int p_1287430;
int _1287433;
int p_1287433;
int _1287436;
int p_1287436;
int _1287439;
int p_1287439;
struct_BoundaryMode_220129 bh_lower_1287446;
struct_BoundaryMode_220129 pbh_lower_1287446;
struct_BoundaryMode_220129 bh_upper_1287457;
struct_BoundaryMode_220129 pbh_upper_1287457;
float _1287474;
float p_1287474;
float _1287477;
float p_1287477;
struct_BoundaryMode_220129 bh_lower_1287481;
struct_BoundaryMode_220129 pbh_lower_1287481;
struct_BoundaryMode_220129 bh_upper_1287487;
struct_BoundaryMode_220129 pbh_upper_1287487;
float _1287503;
float p_1287503;
float _1287506;
float p_1287506;
struct_BoundaryMode_220129 bh_lower_1287512;
struct_BoundaryMode_220129 pbh_lower_1287512;
struct_BoundaryMode_220129 bh_upper_1287516;
struct_BoundaryMode_220129 pbh_upper_1287516;
float _1287532;
float p_1287532;
float _1287535;
float p_1287535;
struct_BoundaryMode_220129 bh_lower_1287541;
struct_BoundaryMode_220129 pbh_lower_1287541;
struct_BoundaryMode_220129 bh_upper_1287545;
struct_BoundaryMode_220129 pbh_upper_1287545;
float _1287561;
float p_1287561;
float _1287564;
float p_1287564;
struct_BoundaryMode_220129 bh_lower_1287568;
struct_BoundaryMode_220129 pbh_lower_1287568;
struct_BoundaryMode_220129 bh_upper_1287574;
struct_BoundaryMode_220129 pbh_upper_1287574;
float _1287590;
float p_1287590;
float _1287593;
float p_1287593;
_1287421 = threadIdx_x();
p_1287421 = _1287421;
l1287419: ;
_1287421 = p_1287421;
_1287424 = blockDim_x();
p_1287424 = _1287424;
l1287422: ;
_1287424 = p_1287424;
_1287427 = blockIdx_x();
p_1287427 = _1287427;
l1287425: ;
_1287427 = p_1287427;
_1287430 = threadIdx_y();
p_1287430 = _1287430;
l1287428: ;
_1287430 = p_1287430;
_1287433 = blockDim_y();
p_1287433 = _1287433;
l1287431: ;
_1287433 = p_1287433;
_1287436 = blockIdx_y();
p_1287436 = _1287436;
l1287434: ;
_1287436 = p_1287436;
_1287439 = blockDim_y();
p_1287439 = _1287439;
l1287437: ;
_1287439 = p_1287439;
int _1287440;
_1287440 = _1287424 * _1287427;
int gid_x_1287441;
gid_x_1287441 = _1287421 + _1287440;
union variant_220130 _1287630;
_1287630.qs32 = gid_x_1287441;
bool _1287442;
_1287442 = gid_x_1287441 < 0;
struct_BoundaryMode_220129 _1287631;
_1287631.e0 = 0;
_1287631.e1 = _1287630;
if (_1287442) goto l1287443; else goto l1287684;
l1287684: ;
pbh_lower_1287446 = _1287631;
goto l1287444;
l1287443: ;
union variant_220130 _1265919_8357;
_1265919_8357.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8359;
_1265920_8359.e0 = 1;
_1265920_8359.e1 = _1265919_8357;
pbh_lower_1287446 = _1265920_8359;
goto l1287444;
l1287444: ;
bh_lower_1287446 = pbh_lower_1287446;
int _1287447;
_1287447 = _1015064_1287417.e2;
int _1287451;
_1287451 = _1287433 * _1287436;
int _1287448;
_1287448 = _1015062_1287415.e2;
int _1287449;
_1287449 = _1287448 - 1;
int _1287450;
_1287450 = _1287449 + _1287430;
int gid_y_1287452;
gid_y_1287452 = _1287450 + _1287451;
union variant_220130 _1287642;
_1287642.qs32 = gid_y_1287452;
bool _1287453;
_1287453 = _1287447 <= gid_y_1287452;
struct_BoundaryMode_220129 _1287643;
_1287643.e0 = 0;
_1287643.e1 = _1287642;
if (_1287453) goto l1287454; else goto l1287683;
l1287683: ;
pbh_upper_1287457 = _1287643;
goto l1287455;
l1287454: ;
union variant_220130 _1265919_8369;
_1265919_8369.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8371;
_1265920_8371.e0 = 1;
_1265920_8371.e1 = _1265919_8369;
pbh_upper_1287457 = _1265920_8371;
goto l1287455;
l1287455: ;
bh_upper_1287457 = pbh_upper_1287457;
unsigned int _1287460;
_1287460 = bh_upper_1287457.e0;
unsigned int _1287458;
_1287458 = bh_lower_1287446.e0;
bool _1287459;
_1287459 = _1287458 == 0;
int _1287466;
_1287466 = _1015064_1287417.e3;
union variant_220130 _1287468;
_1287468 = bh_lower_1287446.e1;
bool _1287461;
_1287461 = _1287460 == 0;
union variant_220130 _1287464;
_1287464 = bh_upper_1287457.e1;
bool _1287462;
_1287462 = _1287459 & _1287461;
if (_1287462) goto l1287463; else goto l1287674;
l1287674: ;
bool _1287675;
_1287675 = _1287458 == 1;
if (_1287675) goto l1287676; else goto l1287678;
l1287678: ;
bool _1287679;
_1287679 = _1287460 == 1;
if (_1287679) goto l1287680; else goto l1287682;
l1287682: ;
// bottom: float r4_1265918_8384;
// bottom: p_1287477 = r4_1265918_8384;
goto l1287475;
l1287680: ;
float c_1287681;
c_1287681 = _1287464.pf32;
p_1287477 = c_1287681;
goto l1287475;
l1287676: ;
float c_1287677;
c_1287677 = _1287468.pf32;
p_1287477 = c_1287677;
goto l1287475;
l1287463: ;
int x_1287469;
x_1287469 = _1287468.qs32;
int y_1287465;
y_1287465 = _1287464.qs32;
int _1287467;
_1287467 = y_1287465 * _1287466;
int _1287470;
_1287470 = _1287467 + x_1287469;
float* idx_1287471;
idx_1287471 = _1015063_1287416 + _1287470;
_1287474 = __ldg(idx_1287471);
p_1287474 = _1287474;
l1287472: ;
_1287474 = p_1287474;
p_1287477 = _1287474;
goto l1287475;
l1287475: ;
_1287477 = p_1287477;
int _1287599;
_1287599 = _1015060_1287413.e3;
int _1287600;
_1287600 = gid_y_1287452 * _1287599;
int _1287601;
_1287601 = _1287600 + gid_x_1287441;
float* idx_1287602;
idx_1287602 = _1015065_1287418 + _1287601;
float _1287603;
_1287603 = *idx_1287602;
if (_1287442) goto l1287478; else goto l1287673;
l1287673: ;
pbh_lower_1287481 = _1287631;
goto l1287479;
l1287478: ;
union variant_220130 _1265919_8386;
_1265919_8386.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8388;
_1265920_8388.e0 = 1;
_1265920_8388.e1 = _1265919_8386;
pbh_lower_1287481 = _1265920_8388;
goto l1287479;
l1287479: ;
bh_lower_1287481 = pbh_lower_1287481;
int _1287482;
_1287482 = -1 + gid_y_1287452;
bool _1287483;
_1287483 = _1287447 <= _1287482;
if (_1287483) goto l1287484; else goto l1287669;
l1287669: ;
union variant_220130 _1287670;
_1287670.qs32 = _1287482;
struct_BoundaryMode_220129 _1287671;
_1287671.e0 = 0;
_1287671.e1 = _1287670;
pbh_upper_1287487 = _1287671;
goto l1287485;
l1287484: ;
union variant_220130 _1265919_8396;
_1265919_8396.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8398;
_1265920_8398.e0 = 1;
_1265920_8398.e1 = _1265919_8396;
pbh_upper_1287487 = _1265920_8398;
goto l1287485;
l1287485: ;
bh_upper_1287487 = pbh_upper_1287487;
unsigned int _1287488;
_1287488 = bh_lower_1287481.e0;
union variant_220130 _1287494;
_1287494 = bh_upper_1287487.e1;
bool _1287489;
_1287489 = _1287488 == 0;
union variant_220130 _1287497;
_1287497 = bh_lower_1287481.e1;
unsigned int _1287490;
_1287490 = bh_upper_1287487.e0;
bool _1287491;
_1287491 = _1287490 == 0;
bool _1287492;
_1287492 = _1287489 & _1287491;
if (_1287492) goto l1287493; else goto l1287660;
l1287660: ;
bool _1287661;
_1287661 = _1287488 == 1;
if (_1287661) goto l1287662; else goto l1287664;
l1287664: ;
bool _1287665;
_1287665 = _1287490 == 1;
if (_1287665) goto l1287666; else goto l1287668;
l1287668: ;
// bottom: float r4_1265918_8410;
// bottom: p_1287506 = r4_1265918_8410;
goto l1287504;
l1287666: ;
float c_1287667;
c_1287667 = _1287494.pf32;
p_1287506 = c_1287667;
goto l1287504;
l1287662: ;
float c_1287663;
c_1287663 = _1287497.pf32;
p_1287506 = c_1287663;
goto l1287504;
l1287493: ;
int y_1287495;
y_1287495 = _1287494.qs32;
int x_1287498;
x_1287498 = _1287497.qs32;
int _1287496;
_1287496 = y_1287495 * _1287466;
int _1287499;
_1287499 = _1287496 + x_1287498;
float* idx_1287500;
idx_1287500 = _1015063_1287416 + _1287499;
_1287503 = __ldg(idx_1287500);
p_1287503 = _1287503;
l1287501: ;
_1287503 = p_1287503;
p_1287506 = _1287503;
goto l1287504;
l1287504: ;
_1287506 = p_1287506;
int _1287507;
_1287507 = -1 + gid_x_1287441;
bool _1287508;
_1287508 = _1287507 < 0;
if (_1287508) goto l1287509; else goto l1287657;
l1287657: ;
union variant_220130 _1287658;
_1287658.qs32 = _1287507;
struct_BoundaryMode_220129 _1287659;
_1287659.e0 = 0;
_1287659.e1 = _1287658;
pbh_lower_1287512 = _1287659;
goto l1287510;
l1287509: ;
union variant_220130 _1265919_8416;
_1265919_8416.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8418;
_1265920_8418.e0 = 1;
_1265920_8418.e1 = _1265919_8416;
pbh_lower_1287512 = _1265920_8418;
goto l1287510;
l1287510: ;
bh_lower_1287512 = pbh_lower_1287512;
if (_1287453) goto l1287513; else goto l1287656;
l1287656: ;
pbh_upper_1287516 = _1287643;
goto l1287514;
l1287513: ;
union variant_220130 _1265919_8422;
_1265919_8422.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8424;
_1265920_8424.e0 = 1;
_1265920_8424.e1 = _1265919_8422;
pbh_upper_1287516 = _1265920_8424;
goto l1287514;
l1287514: ;
bh_upper_1287516 = pbh_upper_1287516;
union variant_220130 _1287523;
_1287523 = bh_upper_1287516.e1;
unsigned int _1287517;
_1287517 = bh_lower_1287512.e0;
unsigned int _1287519;
_1287519 = bh_upper_1287516.e0;
union variant_220130 _1287526;
_1287526 = bh_lower_1287512.e1;
bool _1287518;
_1287518 = _1287517 == 0;
bool _1287520;
_1287520 = _1287519 == 0;
bool _1287521;
_1287521 = _1287518 & _1287520;
if (_1287521) goto l1287522; else goto l1287647;
l1287647: ;
bool _1287648;
_1287648 = _1287517 == 1;
if (_1287648) goto l1287649; else goto l1287651;
l1287651: ;
bool _1287652;
_1287652 = _1287519 == 1;
if (_1287652) goto l1287653; else goto l1287655;
l1287655: ;
// bottom: float r4_1265918_8436;
// bottom: p_1287535 = r4_1265918_8436;
goto l1287533;
l1287653: ;
float c_1287654;
c_1287654 = _1287523.pf32;
p_1287535 = c_1287654;
goto l1287533;
l1287649: ;
float c_1287650;
c_1287650 = _1287526.pf32;
p_1287535 = c_1287650;
goto l1287533;
l1287522: ;
int y_1287524;
y_1287524 = _1287523.qs32;
int _1287525;
_1287525 = y_1287524 * _1287466;
int x_1287527;
x_1287527 = _1287526.qs32;
int _1287528;
_1287528 = _1287525 + x_1287527;
float* idx_1287529;
idx_1287529 = _1015063_1287416 + _1287528;
_1287532 = __ldg(idx_1287529);
p_1287532 = _1287532;
l1287530: ;
_1287532 = p_1287532;
p_1287535 = _1287532;
goto l1287533;
l1287533: ;
_1287535 = p_1287535;
int _1287536;
_1287536 = 1 + gid_x_1287441;
bool _1287537;
_1287537 = _1287536 < 0;
if (_1287537) goto l1287538; else goto l1287644;
l1287644: ;
union variant_220130 _1287645;
_1287645.qs32 = _1287536;
struct_BoundaryMode_220129 _1287646;
_1287646.e0 = 0;
_1287646.e1 = _1287645;
pbh_lower_1287541 = _1287646;
goto l1287539;
l1287538: ;
union variant_220130 _1265919_8442;
_1265919_8442.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8444;
_1265920_8444.e0 = 1;
_1265920_8444.e1 = _1265919_8442;
pbh_lower_1287541 = _1265920_8444;
goto l1287539;
l1287539: ;
bh_lower_1287541 = pbh_lower_1287541;
if (_1287453) goto l1287542; else goto l1287641;
l1287641: ;
pbh_upper_1287545 = _1287643;
goto l1287543;
l1287542: ;
union variant_220130 _1265919_8448;
_1265919_8448.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8450;
_1265920_8450.e0 = 1;
_1265920_8450.e1 = _1265919_8448;
pbh_upper_1287545 = _1265920_8450;
goto l1287543;
l1287543: ;
bh_upper_1287545 = pbh_upper_1287545;
unsigned int _1287546;
_1287546 = bh_lower_1287541.e0;
unsigned int _1287548;
_1287548 = bh_upper_1287545.e0;
union variant_220130 _1287552;
_1287552 = bh_upper_1287545.e1;
union variant_220130 _1287555;
_1287555 = bh_lower_1287541.e1;
bool _1287547;
_1287547 = _1287546 == 0;
bool _1287549;
_1287549 = _1287548 == 0;
bool _1287550;
_1287550 = _1287547 & _1287549;
if (_1287550) goto l1287551; else goto l1287632;
l1287632: ;
bool _1287633;
_1287633 = _1287546 == 1;
if (_1287633) goto l1287634; else goto l1287636;
l1287636: ;
bool _1287637;
_1287637 = _1287548 == 1;
if (_1287637) goto l1287638; else goto l1287640;
l1287640: ;
// bottom: float r4_1265918_8462;
// bottom: p_1287564 = r4_1265918_8462;
goto l1287562;
l1287638: ;
float c_1287639;
c_1287639 = _1287552.pf32;
p_1287564 = c_1287639;
goto l1287562;
l1287634: ;
float c_1287635;
c_1287635 = _1287555.pf32;
p_1287564 = c_1287635;
goto l1287562;
l1287551: ;
int y_1287553;
y_1287553 = _1287552.qs32;
int x_1287556;
x_1287556 = _1287555.qs32;
int _1287554;
_1287554 = y_1287553 * _1287466;
int _1287557;
_1287557 = _1287554 + x_1287556;
float* idx_1287558;
idx_1287558 = _1015063_1287416 + _1287557;
_1287561 = __ldg(idx_1287558);
p_1287561 = _1287561;
l1287559: ;
_1287561 = p_1287561;
p_1287564 = _1287561;
goto l1287562;
l1287562: ;
_1287564 = p_1287564;
if (_1287442) goto l1287565; else goto l1287629;
l1287629: ;
pbh_lower_1287568 = _1287631;
goto l1287566;
l1287565: ;
union variant_220130 _1265919_8463;
_1265919_8463.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8465;
_1265920_8465.e0 = 1;
_1265920_8465.e1 = _1265919_8463;
pbh_lower_1287568 = _1265920_8465;
goto l1287566;
l1287566: ;
bh_lower_1287568 = pbh_lower_1287568;
int _1287569;
_1287569 = 1 + gid_y_1287452;
bool _1287570;
_1287570 = _1287447 <= _1287569;
if (_1287570) goto l1287571; else goto l1287626;
l1287626: ;
union variant_220130 _1287627;
_1287627.qs32 = _1287569;
struct_BoundaryMode_220129 _1287628;
_1287628.e0 = 0;
_1287628.e1 = _1287627;
pbh_upper_1287574 = _1287628;
goto l1287572;
l1287571: ;
union variant_220130 _1265919_8473;
_1265919_8473.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8475;
_1265920_8475.e0 = 1;
_1265920_8475.e1 = _1265919_8473;
pbh_upper_1287574 = _1265920_8475;
goto l1287572;
l1287572: ;
bh_upper_1287574 = pbh_upper_1287574;
unsigned int _1287575;
_1287575 = bh_lower_1287568.e0;
union variant_220130 _1287581;
_1287581 = bh_upper_1287574.e1;
bool _1287576;
_1287576 = _1287575 == 0;
unsigned int _1287577;
_1287577 = bh_upper_1287574.e0;
bool _1287578;
_1287578 = _1287577 == 0;
union variant_220130 _1287584;
_1287584 = bh_lower_1287568.e1;
bool _1287579;
_1287579 = _1287576 & _1287578;
if (_1287579) goto l1287580; else goto l1287617;
l1287617: ;
bool _1287618;
_1287618 = _1287575 == 1;
if (_1287618) goto l1287619; else goto l1287621;
l1287621: ;
bool _1287622;
_1287622 = _1287577 == 1;
if (_1287622) goto l1287623; else goto l1287625;
l1287625: ;
// bottom: float r4_1265918_8487;
// bottom: p_1287593 = r4_1265918_8487;
goto l1287591;
l1287623: ;
float c_1287624;
c_1287624 = _1287581.pf32;
p_1287593 = c_1287624;
goto l1287591;
l1287619: ;
float c_1287620;
c_1287620 = _1287584.pf32;
p_1287593 = c_1287620;
goto l1287591;
l1287580: ;
int y_1287582;
y_1287582 = _1287581.qs32;
int x_1287585;
x_1287585 = _1287584.qs32;
int _1287583;
_1287583 = y_1287582 * _1287466;
int _1287586;
_1287586 = _1287583 + x_1287585;
float* idx_1287587;
idx_1287587 = _1015063_1287416 + _1287586;
_1287590 = __ldg(idx_1287587);
p_1287590 = _1287590;
l1287588: ;
_1287590 = p_1287590;
p_1287593 = _1287590;
goto l1287591;
l1287591: ;
_1287593 = p_1287593;
float _1287604;
_1287604 = _1287603;
float _1287613;
_1287613 = 2.500000e-01f * _1287593;
float _1287611;
_1287611 = 2.500000e-01f * _1287564;
float _1287607;
_1287607 = 2.500000e-01f * _1287506;
float _1287608;
_1287608 = 0.000000e+00f + _1287607;
int _1287594;
_1287594 = _1015062_1287415.e3;
float _1287598;
_1287598 = 2.000000e-01f * _1287477;
float _1287609;
_1287609 = 2.500000e-01f * _1287535;
float _1287605;
_1287605 = 2.000000e-01f * _1287604;
int _1287595;
_1287595 = gid_y_1287452 * _1287594;
float _1287610;
_1287610 = _1287608 + _1287609;
float _1287606;
_1287606 = _1287598 + _1287605;
int _1287596;
_1287596 = _1287595 + gid_x_1287441;
float _1287612;
_1287612 = _1287610 + _1287611;
float* idx_1287597;
idx_1287597 = _1015061_1287414 + _1287596;
float _1287614;
_1287614 = _1287612 + _1287613;
float val_1287615;
val_1287615 = _1287606 + _1287614;
*idx_1287597 = val_1287615;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1045669(float* _1045672_1277878, struct_Img_220118 _1045673_1277879, struct_Img_220118 _1045674_1277880, float* _1045675_1277881, struct_Img_220118 _1045676_1277882, float* _1045677_1277883) {
int _1277886;
int p_1277886;
int _1277889;
int p_1277889;
int _1277892;
int p_1277892;
int _1277895;
int p_1277895;
int _1277898;
int p_1277898;
int _1277901;
int p_1277901;
int _1277904;
int p_1277904;
struct_BoundaryMode_220129 bh_upper_1277915;
struct_BoundaryMode_220129 pbh_upper_1277915;
float _1277930;
float p_1277930;
float _1277933;
float p_1277933;
struct_BoundaryMode_220129 bh_upper_1277937;
struct_BoundaryMode_220129 pbh_upper_1277937;
float _1277948;
float p_1277948;
float _1277951;
float p_1277951;
struct_BoundaryMode_220129 bh_upper_1277957;
struct_BoundaryMode_220129 pbh_upper_1277957;
float _1277967;
float p_1277967;
float _1277970;
float p_1277970;
struct_BoundaryMode_220129 bh_upper_1277976;
struct_BoundaryMode_220129 pbh_upper_1277976;
float _1277986;
float p_1277986;
float _1277989;
float p_1277989;
struct_BoundaryMode_220129 bh_upper_1277993;
struct_BoundaryMode_220129 pbh_upper_1277993;
float _1278005;
float p_1278005;
float _1278008;
float p_1278008;
_1277886 = threadIdx_x();
p_1277886 = _1277886;
l1277884: ;
_1277886 = p_1277886;
_1277889 = blockDim_x();
p_1277889 = _1277889;
l1277887: ;
_1277889 = p_1277889;
_1277892 = blockIdx_x();
p_1277892 = _1277892;
l1277890: ;
_1277892 = p_1277892;
_1277895 = threadIdx_y();
p_1277895 = _1277895;
l1277893: ;
_1277895 = p_1277895;
_1277898 = blockDim_y();
p_1277898 = _1277898;
l1277896: ;
_1277898 = p_1277898;
_1277901 = blockIdx_y();
p_1277901 = _1277901;
l1277899: ;
_1277901 = p_1277901;
_1277904 = blockDim_y();
p_1277904 = _1277904;
l1277902: ;
_1277904 = p_1277904;
int _1277906;
_1277906 = _1045676_1277882.e1;
int _1277905;
_1277905 = _1045673_1277879.e1;
int _1277909;
_1277909 = _1277889 * _1277892;
int _1277907;
_1277907 = _1277906 - 128;
int _1277908;
_1277908 = _1277907 + _1277886;
int gid_x_1277910;
gid_x_1277910 = _1277908 + _1277909;
bool _1277911;
_1277911 = _1277905 <= gid_x_1277910;
union variant_220130 _1278038;
_1278038.qs32 = gid_x_1277910;
struct_BoundaryMode_220129 _1278039;
_1278039.e0 = 0;
_1278039.e1 = _1278038;
if (_1277911) goto l1277912; else goto l1278068;
l1278068: ;
pbh_upper_1277915 = _1278039;
goto l1277913;
l1277912: ;
union variant_220130 _1265919_8502;
_1265919_8502.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8504;
_1265920_8504.e0 = 1;
_1265920_8504.e1 = _1265919_8502;
pbh_upper_1277915 = _1265920_8504;
goto l1277913;
l1277913: ;
bh_upper_1277915 = pbh_upper_1277915;
int _1277922;
_1277922 = _1045673_1277879.e3;
union variant_220130 _1277924;
_1277924 = bh_upper_1277915.e1;
int _1277919;
_1277919 = _1277898 * _1277901;
int gid_y_1277920;
gid_y_1277920 = _1277895 + _1277919;
unsigned int _1277916;
_1277916 = bh_upper_1277915.e0;
int _1277921;
_1277921 = 1 + gid_y_1277920;
bool _1277917;
_1277917 = _1277916 == 0;
int _1277923;
_1277923 = _1277921 * _1277922;
if (_1277917) goto l1277918; else goto l1278063;
l1278063: ;
bool _1278064;
_1278064 = _1277916 == 1;
if (_1278064) goto l1278065; else goto l1278067;
l1278067: ;
// bottom: float r4_1265918_8514;
// bottom: p_1277933 = r4_1265918_8514;
goto l1277931;
l1278065: ;
float c_1278066;
c_1278066 = _1277924.pf32;
p_1277933 = c_1278066;
goto l1277931;
l1277918: ;
int x_1277925;
x_1277925 = _1277924.qs32;
int _1277926;
_1277926 = _1277923 + x_1277925;
float* idx_1277927;
idx_1277927 = _1045672_1277878 + _1277926;
_1277930 = __ldg(idx_1277927);
p_1277930 = _1277930;
l1277928: ;
_1277930 = p_1277930;
p_1277933 = _1277930;
goto l1277931;
l1277931: ;
_1277933 = p_1277933;
int _1278014;
_1278014 = _1045674_1277880.e3;
int _1278015;
_1278015 = _1277921 * _1278014;
int _1278016;
_1278016 = _1278015 + gid_x_1277910;
float* idx_1278017;
idx_1278017 = _1045677_1277883 + _1278016;
float _1278018;
_1278018 = *idx_1278017;
if (_1277911) goto l1277934; else goto l1278062;
l1278062: ;
pbh_upper_1277937 = _1278039;
goto l1277935;
l1277934: ;
union variant_220130 _1265919_8516;
_1265919_8516.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8518;
_1265920_8518.e0 = 1;
_1265920_8518.e1 = _1265919_8516;
pbh_upper_1277937 = _1265920_8518;
goto l1277935;
l1277935: ;
bh_upper_1277937 = pbh_upper_1277937;
unsigned int _1277938;
_1277938 = bh_upper_1277937.e0;
bool _1277939;
_1277939 = _1277938 == 0;
union variant_220130 _1277942;
_1277942 = bh_upper_1277937.e1;
if (_1277939) goto l1277940; else goto l1278056;
l1278056: ;
bool _1278057;
_1278057 = _1277938 == 1;
if (_1278057) goto l1278058; else goto l1278060;
l1278060: ;
// bottom: float r4_1265918_8526;
// bottom: p_1277951 = r4_1265918_8526;
goto l1277949;
l1278058: ;
float c_1278059;
c_1278059 = _1277942.pf32;
p_1277951 = c_1278059;
goto l1277949;
l1277940: ;
int x_1277943;
x_1277943 = _1277942.qs32;
int _1277941;
_1277941 = gid_y_1277920 * _1277922;
int _1277944;
_1277944 = _1277941 + x_1277943;
float* idx_1277945;
idx_1277945 = _1045672_1277878 + _1277944;
_1277948 = __ldg(idx_1277945);
p_1277948 = _1277948;
l1277946: ;
_1277948 = p_1277948;
p_1277951 = _1277948;
goto l1277949;
l1277949: ;
_1277951 = p_1277951;
int _1277952;
_1277952 = -1 + gid_x_1277910;
bool _1277953;
_1277953 = _1277905 <= _1277952;
if (_1277953) goto l1277954; else goto l1278053;
l1278053: ;
union variant_220130 _1278054;
_1278054.qs32 = _1277952;
struct_BoundaryMode_220129 _1278055;
_1278055.e0 = 0;
_1278055.e1 = _1278054;
pbh_upper_1277957 = _1278055;
goto l1277955;
l1277954: ;
union variant_220130 _1265919_8531;
_1265919_8531.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8533;
_1265920_8533.e0 = 1;
_1265920_8533.e1 = _1265919_8531;
pbh_upper_1277957 = _1265920_8533;
goto l1277955;
l1277955: ;
bh_upper_1277957 = pbh_upper_1277957;
unsigned int _1277958;
_1277958 = bh_upper_1277957.e0;
union variant_220130 _1277961;
_1277961 = bh_upper_1277957.e1;
bool _1277959;
_1277959 = _1277958 == 0;
if (_1277959) goto l1277960; else goto l1278048;
l1278048: ;
bool _1278049;
_1278049 = _1277958 == 1;
if (_1278049) goto l1278050; else goto l1278052;
l1278052: ;
// bottom: float r4_1265918_8541;
// bottom: p_1277970 = r4_1265918_8541;
goto l1277968;
l1278050: ;
float c_1278051;
c_1278051 = _1277961.pf32;
p_1277970 = c_1278051;
goto l1277968;
l1277960: ;
int x_1277962;
x_1277962 = _1277961.qs32;
int _1277963;
_1277963 = _1277923 + x_1277962;
float* idx_1277964;
idx_1277964 = _1045672_1277878 + _1277963;
_1277967 = __ldg(idx_1277964);
p_1277967 = _1277967;
l1277965: ;
_1277967 = p_1277967;
p_1277970 = _1277967;
goto l1277968;
l1277968: ;
_1277970 = p_1277970;
int _1277971;
_1277971 = 1 + gid_x_1277910;
bool _1277972;
_1277972 = _1277905 <= _1277971;
if (_1277972) goto l1277973; else goto l1278045;
l1278045: ;
union variant_220130 _1278046;
_1278046.qs32 = _1277971;
struct_BoundaryMode_220129 _1278047;
_1278047.e0 = 0;
_1278047.e1 = _1278046;
pbh_upper_1277976 = _1278047;
goto l1277974;
l1277973: ;
union variant_220130 _1265919_8546;
_1265919_8546.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8548;
_1265920_8548.e0 = 1;
_1265920_8548.e1 = _1265919_8546;
pbh_upper_1277976 = _1265920_8548;
goto l1277974;
l1277974: ;
bh_upper_1277976 = pbh_upper_1277976;
unsigned int _1277977;
_1277977 = bh_upper_1277976.e0;
union variant_220130 _1277980;
_1277980 = bh_upper_1277976.e1;
bool _1277978;
_1277978 = _1277977 == 0;
if (_1277978) goto l1277979; else goto l1278040;
l1278040: ;
bool _1278041;
_1278041 = _1277977 == 1;
if (_1278041) goto l1278042; else goto l1278044;
l1278044: ;
// bottom: float r4_1265918_8556;
// bottom: p_1277989 = r4_1265918_8556;
goto l1277987;
l1278042: ;
float c_1278043;
c_1278043 = _1277980.pf32;
p_1277989 = c_1278043;
goto l1277987;
l1277979: ;
int x_1277981;
x_1277981 = _1277980.qs32;
int _1277982;
_1277982 = _1277923 + x_1277981;
float* idx_1277983;
idx_1277983 = _1045672_1277878 + _1277982;
_1277986 = __ldg(idx_1277983);
p_1277986 = _1277986;
l1277984: ;
_1277986 = p_1277986;
p_1277989 = _1277986;
goto l1277987;
l1277987: ;
_1277989 = p_1277989;
if (_1277911) goto l1277990; else goto l1278037;
l1278037: ;
pbh_upper_1277993 = _1278039;
goto l1277991;
l1277990: ;
union variant_220130 _1265919_8557;
_1265919_8557.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8559;
_1265920_8559.e0 = 1;
_1265920_8559.e1 = _1265919_8557;
pbh_upper_1277993 = _1265920_8559;
goto l1277991;
l1277991: ;
bh_upper_1277993 = pbh_upper_1277993;
union variant_220130 _1277999;
_1277999 = bh_upper_1277993.e1;
unsigned int _1277994;
_1277994 = bh_upper_1277993.e0;
bool _1277995;
_1277995 = _1277994 == 0;
if (_1277995) goto l1277996; else goto l1278032;
l1278032: ;
bool _1278033;
_1278033 = _1277994 == 1;
if (_1278033) goto l1278034; else goto l1278036;
l1278036: ;
// bottom: float r4_1265918_8567;
// bottom: p_1278008 = r4_1265918_8567;
goto l1278006;
l1278034: ;
float c_1278035;
c_1278035 = _1277999.pf32;
p_1278008 = c_1278035;
goto l1278006;
l1277996: ;
int x_1278000;
x_1278000 = _1277999.qs32;
int _1277997;
_1277997 = 2 + gid_y_1277920;
int _1277998;
_1277998 = _1277997 * _1277922;
int _1278001;
_1278001 = _1277998 + x_1278000;
float* idx_1278002;
idx_1278002 = _1045672_1277878 + _1278001;
_1278005 = __ldg(idx_1278002);
p_1278005 = _1278005;
l1278003: ;
_1278005 = p_1278005;
p_1278008 = _1278005;
goto l1278006;
l1278006: ;
_1278008 = p_1278008;
float _1278024;
_1278024 = 2.500000e-01f * _1277970;
float _1278019;
_1278019 = _1278018;
float _1278020;
_1278020 = 2.000000e-01f * _1278019;
int _1278009;
_1278009 = _1045676_1277882.e3;
float _1278013;
_1278013 = 2.000000e-01f * _1277933;
float _1278028;
_1278028 = 2.500000e-01f * _1278008;
float _1278021;
_1278021 = _1278013 + _1278020;
float _1278022;
_1278022 = 2.500000e-01f * _1277951;
float _1278023;
_1278023 = 0.000000e+00f + _1278022;
float _1278025;
_1278025 = _1278023 + _1278024;
float _1278026;
_1278026 = 2.500000e-01f * _1277989;
int _1278010;
_1278010 = _1277921 * _1278009;
float _1278027;
_1278027 = _1278025 + _1278026;
int _1278011;
_1278011 = _1278010 + gid_x_1277910;
float _1278029;
_1278029 = _1278027 + _1278028;
float* idx_1278012;
idx_1278012 = _1045675_1277881 + _1278011;
float val_1278030;
val_1278030 = _1278021 + _1278029;
*idx_1278012 = val_1278030;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1030157(struct_Img_220118 _1030160_1286798, float* _1030161_1286799, float* _1030162_1286800, struct_Img_220118 _1030163_1286801, struct_Img_220118 _1030164_1286802, float* _1030165_1286803) {
int _1286806;
int p_1286806;
int _1286809;
int p_1286809;
int _1286812;
int p_1286812;
int _1286815;
int p_1286815;
int _1286818;
int p_1286818;
int _1286821;
int p_1286821;
int _1286824;
int p_1286824;
struct_BoundaryMode_220129 bh_lower_1286831;
struct_BoundaryMode_220129 pbh_lower_1286831;
float _1286846;
float p_1286846;
float _1286849;
float p_1286849;
struct_BoundaryMode_220129 bh_lower_1286855;
struct_BoundaryMode_220129 pbh_lower_1286855;
float _1286867;
float p_1286867;
float _1286870;
float p_1286870;
struct_BoundaryMode_220129 bh_lower_1286874;
struct_BoundaryMode_220129 pbh_lower_1286874;
float _1286886;
float p_1286886;
float _1286889;
float p_1286889;
struct_BoundaryMode_220129 bh_lower_1286893;
struct_BoundaryMode_220129 pbh_lower_1286893;
float _1286905;
float p_1286905;
float _1286908;
float p_1286908;
struct_BoundaryMode_220129 bh_lower_1286914;
struct_BoundaryMode_220129 pbh_lower_1286914;
float _1286926;
float p_1286926;
float _1286929;
float p_1286929;
_1286806 = threadIdx_x();
p_1286806 = _1286806;
l1286804: ;
_1286806 = p_1286806;
_1286809 = blockDim_x();
p_1286809 = _1286809;
l1286807: ;
_1286809 = p_1286809;
_1286812 = blockIdx_x();
p_1286812 = _1286812;
l1286810: ;
_1286812 = p_1286812;
_1286815 = threadIdx_y();
p_1286815 = _1286815;
l1286813: ;
_1286815 = p_1286815;
_1286818 = blockDim_y();
p_1286818 = _1286818;
l1286816: ;
_1286818 = p_1286818;
_1286821 = blockIdx_y();
p_1286821 = _1286821;
l1286819: ;
_1286821 = p_1286821;
_1286824 = blockDim_y();
p_1286824 = _1286824;
l1286822: ;
_1286824 = p_1286824;
int _1286825;
_1286825 = _1286818 * _1286821;
int gid_y_1286826;
gid_y_1286826 = _1286815 + _1286825;
union variant_220130 _1286969;
_1286969.qs32 = gid_y_1286826;
bool _1286827;
_1286827 = gid_y_1286826 < 0;
struct_BoundaryMode_220129 _1286970;
_1286970.e0 = 0;
_1286970.e1 = _1286969;
if (_1286827) goto l1286828; else goto l1286991;
l1286991: ;
pbh_lower_1286831 = _1286970;
goto l1286829;
l1286828: ;
union variant_220130 _1265919_8581;
_1265919_8581.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8583;
_1265920_8583.e0 = 1;
_1265920_8583.e1 = _1265919_8581;
pbh_lower_1286831 = _1265920_8583;
goto l1286829;
l1286829: ;
bh_lower_1286831 = pbh_lower_1286831;
union variant_220130 _1286835;
_1286835 = bh_lower_1286831.e1;
int _1286839;
_1286839 = _1286809 * _1286812;
int _1286837;
_1286837 = _1030163_1286801.e3;
unsigned int _1286832;
_1286832 = bh_lower_1286831.e0;
int gid_x_1286840;
gid_x_1286840 = _1286806 + _1286839;
bool _1286833;
_1286833 = _1286832 == 0;
if (_1286833) goto l1286834; else goto l1286986;
l1286986: ;
bool _1286987;
_1286987 = _1286832 == 1;
if (_1286987) goto l1286988; else goto l1286990;
l1286990: ;
// bottom: float r4_1265918_8592;
// bottom: p_1286849 = r4_1265918_8592;
goto l1286847;
l1286988: ;
float c_1286989;
c_1286989 = _1286835.pf32;
p_1286849 = c_1286989;
goto l1286847;
l1286834: ;
int y_1286836;
y_1286836 = _1286835.qs32;
int _1286838;
_1286838 = y_1286836 * _1286837;
int _1286841;
_1286841 = _1286838 + gid_x_1286840;
int _1286842;
_1286842 = 128 + _1286841;
float* idx_1286843;
idx_1286843 = _1030162_1286800 + _1286842;
_1286846 = __ldg(idx_1286843);
p_1286846 = _1286846;
l1286844: ;
_1286846 = p_1286846;
p_1286849 = _1286846;
goto l1286847;
l1286847: ;
_1286849 = p_1286849;
int _1286850;
_1286850 = -1 + gid_y_1286826;
int _1286936;
_1286936 = _1030160_1286798.e3;
bool _1286851;
_1286851 = _1286850 < 0;
int _1286937;
_1286937 = gid_y_1286826 * _1286936;
int _1286938;
_1286938 = _1286937 + gid_x_1286840;
int _1286939;
_1286939 = 128 + _1286938;
float* idx_1286940;
idx_1286940 = _1030165_1286803 + _1286939;
float _1286941;
_1286941 = *idx_1286940;
if (_1286851) goto l1286852; else goto l1286983;
l1286983: ;
union variant_220130 _1286984;
_1286984.qs32 = _1286850;
struct_BoundaryMode_220129 _1286985;
_1286985.e0 = 0;
_1286985.e1 = _1286984;
pbh_lower_1286855 = _1286985;
goto l1286853;
l1286852: ;
union variant_220130 _1265919_8601;
_1265919_8601.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8603;
_1265920_8603.e0 = 1;
_1265920_8603.e1 = _1265919_8601;
pbh_lower_1286855 = _1265920_8603;
goto l1286853;
l1286853: ;
bh_lower_1286855 = pbh_lower_1286855;
union variant_220130 _1286859;
_1286859 = bh_lower_1286855.e1;
unsigned int _1286856;
_1286856 = bh_lower_1286855.e0;
bool _1286857;
_1286857 = _1286856 == 0;
if (_1286857) goto l1286858; else goto l1286977;
l1286977: ;
bool _1286978;
_1286978 = _1286856 == 1;
if (_1286978) goto l1286979; else goto l1286981;
l1286981: ;
// bottom: float r4_1265918_8611;
// bottom: p_1286870 = r4_1265918_8611;
goto l1286868;
l1286979: ;
float c_1286980;
c_1286980 = _1286859.pf32;
p_1286870 = c_1286980;
goto l1286868;
l1286858: ;
int y_1286860;
y_1286860 = _1286859.qs32;
int _1286861;
_1286861 = y_1286860 * _1286837;
int _1286862;
_1286862 = _1286861 + gid_x_1286840;
int _1286863;
_1286863 = 128 + _1286862;
float* idx_1286864;
idx_1286864 = _1030162_1286800 + _1286863;
_1286867 = __ldg(idx_1286864);
p_1286867 = _1286867;
l1286865: ;
_1286867 = p_1286867;
p_1286870 = _1286867;
goto l1286868;
l1286868: ;
_1286870 = p_1286870;
if (_1286827) goto l1286871; else goto l1286976;
l1286976: ;
pbh_lower_1286874 = _1286970;
goto l1286872;
l1286871: ;
union variant_220130 _1265919_8613;
_1265919_8613.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8615;
_1265920_8615.e0 = 1;
_1265920_8615.e1 = _1265919_8613;
pbh_lower_1286874 = _1265920_8615;
goto l1286872;
l1286872: ;
bh_lower_1286874 = pbh_lower_1286874;
union variant_220130 _1286878;
_1286878 = bh_lower_1286874.e1;
unsigned int _1286875;
_1286875 = bh_lower_1286874.e0;
bool _1286876;
_1286876 = _1286875 == 0;
if (_1286876) goto l1286877; else goto l1286971;
l1286971: ;
bool _1286972;
_1286972 = _1286875 == 1;
if (_1286972) goto l1286973; else goto l1286975;
l1286975: ;
// bottom: float r4_1265918_8623;
// bottom: p_1286889 = r4_1265918_8623;
goto l1286887;
l1286973: ;
float c_1286974;
c_1286974 = _1286878.pf32;
p_1286889 = c_1286974;
goto l1286887;
l1286877: ;
int y_1286879;
y_1286879 = _1286878.qs32;
int _1286880;
_1286880 = y_1286879 * _1286837;
int _1286881;
_1286881 = _1286880 + gid_x_1286840;
int _1286882;
_1286882 = 127 + _1286881;
float* idx_1286883;
idx_1286883 = _1030162_1286800 + _1286882;
_1286886 = __ldg(idx_1286883);
p_1286886 = _1286886;
l1286884: ;
_1286886 = p_1286886;
p_1286889 = _1286886;
goto l1286887;
l1286887: ;
_1286889 = p_1286889;
if (_1286827) goto l1286890; else goto l1286968;
l1286968: ;
pbh_lower_1286893 = _1286970;
goto l1286891;
l1286890: ;
union variant_220130 _1265919_8625;
_1265919_8625.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8627;
_1265920_8627.e0 = 1;
_1265920_8627.e1 = _1265919_8625;
pbh_lower_1286893 = _1265920_8627;
goto l1286891;
l1286891: ;
bh_lower_1286893 = pbh_lower_1286893;
unsigned int _1286894;
_1286894 = bh_lower_1286893.e0;
bool _1286895;
_1286895 = _1286894 == 0;
union variant_220130 _1286897;
_1286897 = bh_lower_1286893.e1;
if (_1286895) goto l1286896; else goto l1286963;
l1286963: ;
bool _1286964;
_1286964 = _1286894 == 1;
if (_1286964) goto l1286965; else goto l1286967;
l1286967: ;
// bottom: float r4_1265918_8635;
// bottom: p_1286908 = r4_1265918_8635;
goto l1286906;
l1286965: ;
float c_1286966;
c_1286966 = _1286897.pf32;
p_1286908 = c_1286966;
goto l1286906;
l1286896: ;
int y_1286898;
y_1286898 = _1286897.qs32;
int _1286899;
_1286899 = y_1286898 * _1286837;
int _1286900;
_1286900 = _1286899 + gid_x_1286840;
int _1286901;
_1286901 = 129 + _1286900;
float* idx_1286902;
idx_1286902 = _1030162_1286800 + _1286901;
_1286905 = __ldg(idx_1286902);
p_1286905 = _1286905;
l1286903: ;
_1286905 = p_1286905;
p_1286908 = _1286905;
goto l1286906;
l1286906: ;
_1286908 = p_1286908;
int _1286909;
_1286909 = 1 + gid_y_1286826;
bool _1286910;
_1286910 = _1286909 < 0;
if (_1286910) goto l1286911; else goto l1286960;
l1286960: ;
union variant_220130 _1286961;
_1286961.qs32 = _1286909;
struct_BoundaryMode_220129 _1286962;
_1286962.e0 = 0;
_1286962.e1 = _1286961;
pbh_lower_1286914 = _1286962;
goto l1286912;
l1286911: ;
union variant_220130 _1265919_8642;
_1265919_8642.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8644;
_1265920_8644.e0 = 1;
_1265920_8644.e1 = _1265919_8642;
pbh_lower_1286914 = _1265920_8644;
goto l1286912;
l1286912: ;
bh_lower_1286914 = pbh_lower_1286914;
unsigned int _1286915;
_1286915 = bh_lower_1286914.e0;
union variant_220130 _1286918;
_1286918 = bh_lower_1286914.e1;
bool _1286916;
_1286916 = _1286915 == 0;
if (_1286916) goto l1286917; else goto l1286955;
l1286955: ;
bool _1286956;
_1286956 = _1286915 == 1;
if (_1286956) goto l1286957; else goto l1286959;
l1286959: ;
// bottom: float r4_1265918_8652;
// bottom: p_1286929 = r4_1265918_8652;
goto l1286927;
l1286957: ;
float c_1286958;
c_1286958 = _1286918.pf32;
p_1286929 = c_1286958;
goto l1286927;
l1286917: ;
int y_1286919;
y_1286919 = _1286918.qs32;
int _1286920;
_1286920 = y_1286919 * _1286837;
int _1286921;
_1286921 = _1286920 + gid_x_1286840;
int _1286922;
_1286922 = 128 + _1286921;
float* idx_1286923;
idx_1286923 = _1030162_1286800 + _1286922;
_1286926 = __ldg(idx_1286923);
p_1286926 = _1286926;
l1286924: ;
_1286926 = p_1286926;
p_1286929 = _1286926;
goto l1286927;
l1286927: ;
_1286929 = p_1286929;
float _1286942;
_1286942 = _1286941;
float _1286951;
_1286951 = 2.500000e-01f * _1286929;
int _1286930;
_1286930 = _1030164_1286802.e3;
float _1286949;
_1286949 = 2.500000e-01f * _1286908;
float _1286947;
_1286947 = 2.500000e-01f * _1286889;
int _1286931;
_1286931 = gid_y_1286826 * _1286930;
float _1286945;
_1286945 = 2.500000e-01f * _1286870;
float _1286943;
_1286943 = 2.000000e-01f * _1286942;
float _1286935;
_1286935 = 2.000000e-01f * _1286849;
int _1286932;
_1286932 = _1286931 + gid_x_1286840;
float _1286946;
_1286946 = 0.000000e+00f + _1286945;
float _1286944;
_1286944 = _1286935 + _1286943;
int _1286933;
_1286933 = 128 + _1286932;
float _1286948;
_1286948 = _1286946 + _1286947;
float* idx_1286934;
idx_1286934 = _1030161_1286799 + _1286933;
float _1286950;
_1286950 = _1286948 + _1286949;
float _1286952;
_1286952 = _1286950 + _1286951;
float val_1286953;
val_1286953 = _1286944 + _1286952;
*idx_1286934 = val_1286953;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1041229(struct_Img_220118 _1041232_1266717, struct_Img_220118 _1041233_1266718, float* _1041234_1266719, struct_Img_220118 _1041235_1266720, float* _1041236_1266721, float* _1041237_1266722) {
int _1266725;
int p_1266725;
int _1266728;
int p_1266728;
int _1266731;
int p_1266731;
int _1266734;
int p_1266734;
int _1266737;
int p_1266737;
int _1266740;
int p_1266740;
int _1266743;
int p_1266743;
struct_BoundaryMode_220129 bh_upper_1266754;
struct_BoundaryMode_220129 pbh_upper_1266754;
float _1266769;
float p_1266769;
float _1266772;
float p_1266772;
struct_BoundaryMode_220129 bh_upper_1266776;
struct_BoundaryMode_220129 pbh_upper_1266776;
float _1266787;
float p_1266787;
float _1266790;
float p_1266790;
struct_BoundaryMode_220129 bh_upper_1266796;
struct_BoundaryMode_220129 pbh_upper_1266796;
float _1266806;
float p_1266806;
float _1266809;
float p_1266809;
struct_BoundaryMode_220129 bh_upper_1266815;
struct_BoundaryMode_220129 pbh_upper_1266815;
float _1266825;
float p_1266825;
float _1266828;
float p_1266828;
struct_BoundaryMode_220129 bh_upper_1266832;
struct_BoundaryMode_220129 pbh_upper_1266832;
float _1266844;
float p_1266844;
float _1266847;
float p_1266847;
_1266725 = threadIdx_x();
p_1266725 = _1266725;
l1266723: ;
_1266725 = p_1266725;
_1266728 = blockDim_x();
p_1266728 = _1266728;
l1266726: ;
_1266728 = p_1266728;
_1266731 = blockIdx_x();
p_1266731 = _1266731;
l1266729: ;
_1266731 = p_1266731;
_1266734 = threadIdx_y();
p_1266734 = _1266734;
l1266732: ;
_1266734 = p_1266734;
_1266737 = blockDim_y();
p_1266737 = _1266737;
l1266735: ;
_1266737 = p_1266737;
_1266740 = blockIdx_y();
p_1266740 = _1266740;
l1266738: ;
_1266740 = p_1266740;
_1266743 = blockDim_y();
p_1266743 = _1266743;
l1266741: ;
_1266743 = p_1266743;
int _1266745;
_1266745 = _1041233_1266718.e1;
int _1266744;
_1266744 = _1041232_1266717.e1;
int _1266748;
_1266748 = _1266728 * _1266731;
int _1266746;
_1266746 = _1266745 - 128;
int _1266747;
_1266747 = _1266746 + _1266725;
int gid_x_1266749;
gid_x_1266749 = _1266747 + _1266748;
union variant_220130 _1266877;
_1266877.qs32 = gid_x_1266749;
bool _1266750;
_1266750 = _1266744 <= gid_x_1266749;
struct_BoundaryMode_220129 _1266878;
_1266878.e0 = 0;
_1266878.e1 = _1266877;
if (_1266750) goto l1266751; else goto l1266907;
l1266907: ;
pbh_upper_1266754 = _1266878;
goto l1266752;
l1266751: ;
union variant_220130 _1265919_8669;
_1265919_8669.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8671;
_1265920_8671.e0 = 1;
_1265920_8671.e1 = _1265919_8669;
pbh_upper_1266754 = _1265920_8671;
goto l1266752;
l1266752: ;
bh_upper_1266754 = pbh_upper_1266754;
unsigned int _1266755;
_1266755 = bh_upper_1266754.e0;
bool _1266756;
_1266756 = _1266755 == 0;
union variant_220130 _1266763;
_1266763 = bh_upper_1266754.e1;
int _1266758;
_1266758 = _1266737 * _1266740;
int _1266761;
_1266761 = _1041232_1266717.e3;
int gid_y_1266759;
gid_y_1266759 = _1266734 + _1266758;
int _1266760;
_1266760 = 1 + gid_y_1266759;
int _1266762;
_1266762 = _1266760 * _1266761;
if (_1266756) goto l1266757; else goto l1266902;
l1266902: ;
bool _1266903;
_1266903 = _1266755 == 1;
if (_1266903) goto l1266904; else goto l1266906;
l1266906: ;
// bottom: float r4_1265918_8681;
// bottom: p_1266772 = r4_1265918_8681;
goto l1266770;
l1266904: ;
float c_1266905;
c_1266905 = _1266763.pf32;
p_1266772 = c_1266905;
goto l1266770;
l1266757: ;
int x_1266764;
x_1266764 = _1266763.qs32;
int _1266765;
_1266765 = _1266762 + x_1266764;
float* idx_1266766;
idx_1266766 = _1041234_1266719 + _1266765;
_1266769 = __ldg(idx_1266766);
p_1266769 = _1266769;
l1266767: ;
_1266769 = p_1266769;
p_1266772 = _1266769;
goto l1266770;
l1266770: ;
_1266772 = p_1266772;
int _1266853;
_1266853 = _1041235_1266720.e3;
int _1266854;
_1266854 = _1266760 * _1266853;
int _1266855;
_1266855 = _1266854 + gid_x_1266749;
float* idx_1266856;
idx_1266856 = _1041237_1266722 + _1266855;
float _1266857;
_1266857 = *idx_1266856;
if (_1266750) goto l1266773; else goto l1266901;
l1266901: ;
pbh_upper_1266776 = _1266878;
goto l1266774;
l1266773: ;
union variant_220130 _1265919_8683;
_1265919_8683.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8685;
_1265920_8685.e0 = 1;
_1265920_8685.e1 = _1265919_8683;
pbh_upper_1266776 = _1265920_8685;
goto l1266774;
l1266774: ;
bh_upper_1266776 = pbh_upper_1266776;
union variant_220130 _1266781;
_1266781 = bh_upper_1266776.e1;
unsigned int _1266777;
_1266777 = bh_upper_1266776.e0;
bool _1266778;
_1266778 = _1266777 == 0;
if (_1266778) goto l1266779; else goto l1266895;
l1266895: ;
bool _1266896;
_1266896 = _1266777 == 1;
if (_1266896) goto l1266897; else goto l1266899;
l1266899: ;
// bottom: float r4_1265918_8693;
// bottom: p_1266790 = r4_1265918_8693;
goto l1266788;
l1266897: ;
float c_1266898;
c_1266898 = _1266781.pf32;
p_1266790 = c_1266898;
goto l1266788;
l1266779: ;
int x_1266782;
x_1266782 = _1266781.qs32;
int _1266780;
_1266780 = gid_y_1266759 * _1266761;
int _1266783;
_1266783 = _1266780 + x_1266782;
float* idx_1266784;
idx_1266784 = _1041234_1266719 + _1266783;
_1266787 = __ldg(idx_1266784);
p_1266787 = _1266787;
l1266785: ;
_1266787 = p_1266787;
p_1266790 = _1266787;
goto l1266788;
l1266788: ;
_1266790 = p_1266790;
int _1266791;
_1266791 = -1 + gid_x_1266749;
bool _1266792;
_1266792 = _1266744 <= _1266791;
if (_1266792) goto l1266793; else goto l1266892;
l1266892: ;
union variant_220130 _1266893;
_1266893.qs32 = _1266791;
struct_BoundaryMode_220129 _1266894;
_1266894.e0 = 0;
_1266894.e1 = _1266893;
pbh_upper_1266796 = _1266894;
goto l1266794;
l1266793: ;
union variant_220130 _1265919_8698;
_1265919_8698.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8700;
_1265920_8700.e0 = 1;
_1265920_8700.e1 = _1265919_8698;
pbh_upper_1266796 = _1265920_8700;
goto l1266794;
l1266794: ;
bh_upper_1266796 = pbh_upper_1266796;
union variant_220130 _1266800;
_1266800 = bh_upper_1266796.e1;
unsigned int _1266797;
_1266797 = bh_upper_1266796.e0;
bool _1266798;
_1266798 = _1266797 == 0;
if (_1266798) goto l1266799; else goto l1266887;
l1266887: ;
bool _1266888;
_1266888 = _1266797 == 1;
if (_1266888) goto l1266889; else goto l1266891;
l1266891: ;
// bottom: float r4_1265918_8708;
// bottom: p_1266809 = r4_1265918_8708;
goto l1266807;
l1266889: ;
float c_1266890;
c_1266890 = _1266800.pf32;
p_1266809 = c_1266890;
goto l1266807;
l1266799: ;
int x_1266801;
x_1266801 = _1266800.qs32;
int _1266802;
_1266802 = _1266762 + x_1266801;
float* idx_1266803;
idx_1266803 = _1041234_1266719 + _1266802;
_1266806 = __ldg(idx_1266803);
p_1266806 = _1266806;
l1266804: ;
_1266806 = p_1266806;
p_1266809 = _1266806;
goto l1266807;
l1266807: ;
_1266809 = p_1266809;
int _1266810;
_1266810 = 1 + gid_x_1266749;
bool _1266811;
_1266811 = _1266744 <= _1266810;
if (_1266811) goto l1266812; else goto l1266884;
l1266884: ;
union variant_220130 _1266885;
_1266885.qs32 = _1266810;
struct_BoundaryMode_220129 _1266886;
_1266886.e0 = 0;
_1266886.e1 = _1266885;
pbh_upper_1266815 = _1266886;
goto l1266813;
l1266812: ;
union variant_220130 _1265919_8713;
_1265919_8713.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8715;
_1265920_8715.e0 = 1;
_1265920_8715.e1 = _1265919_8713;
pbh_upper_1266815 = _1265920_8715;
goto l1266813;
l1266813: ;
bh_upper_1266815 = pbh_upper_1266815;
union variant_220130 _1266819;
_1266819 = bh_upper_1266815.e1;
unsigned int _1266816;
_1266816 = bh_upper_1266815.e0;
bool _1266817;
_1266817 = _1266816 == 0;
if (_1266817) goto l1266818; else goto l1266879;
l1266879: ;
bool _1266880;
_1266880 = _1266816 == 1;
if (_1266880) goto l1266881; else goto l1266883;
l1266883: ;
// bottom: float r4_1265918_8723;
// bottom: p_1266828 = r4_1265918_8723;
goto l1266826;
l1266881: ;
float c_1266882;
c_1266882 = _1266819.pf32;
p_1266828 = c_1266882;
goto l1266826;
l1266818: ;
int x_1266820;
x_1266820 = _1266819.qs32;
int _1266821;
_1266821 = _1266762 + x_1266820;
float* idx_1266822;
idx_1266822 = _1041234_1266719 + _1266821;
_1266825 = __ldg(idx_1266822);
p_1266825 = _1266825;
l1266823: ;
_1266825 = p_1266825;
p_1266828 = _1266825;
goto l1266826;
l1266826: ;
_1266828 = p_1266828;
if (_1266750) goto l1266829; else goto l1266876;
l1266876: ;
pbh_upper_1266832 = _1266878;
goto l1266830;
l1266829: ;
union variant_220130 _1265919_8724;
_1265919_8724.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8726;
_1265920_8726.e0 = 1;
_1265920_8726.e1 = _1265919_8724;
pbh_upper_1266832 = _1265920_8726;
goto l1266830;
l1266830: ;
bh_upper_1266832 = pbh_upper_1266832;
union variant_220130 _1266838;
_1266838 = bh_upper_1266832.e1;
unsigned int _1266833;
_1266833 = bh_upper_1266832.e0;
bool _1266834;
_1266834 = _1266833 == 0;
if (_1266834) goto l1266835; else goto l1266871;
l1266871: ;
bool _1266872;
_1266872 = _1266833 == 1;
if (_1266872) goto l1266873; else goto l1266875;
l1266875: ;
// bottom: float r4_1265918_8734;
// bottom: p_1266847 = r4_1265918_8734;
goto l1266845;
l1266873: ;
float c_1266874;
c_1266874 = _1266838.pf32;
p_1266847 = c_1266874;
goto l1266845;
l1266835: ;
int x_1266839;
x_1266839 = _1266838.qs32;
int _1266836;
_1266836 = 2 + gid_y_1266759;
int _1266837;
_1266837 = _1266836 * _1266761;
int _1266840;
_1266840 = _1266837 + x_1266839;
float* idx_1266841;
idx_1266841 = _1041234_1266719 + _1266840;
_1266844 = __ldg(idx_1266841);
p_1266844 = _1266844;
l1266842: ;
_1266844 = p_1266844;
p_1266847 = _1266844;
goto l1266845;
l1266845: ;
_1266847 = p_1266847;
float _1266861;
_1266861 = 2.500000e-01f * _1266790;
float _1266867;
_1266867 = 2.500000e-01f * _1266847;
float _1266863;
_1266863 = 2.500000e-01f * _1266809;
float _1266858;
_1266858 = _1266857;
float _1266862;
_1266862 = 0.000000e+00f + _1266861;
float _1266852;
_1266852 = 2.000000e-01f * _1266772;
float _1266865;
_1266865 = 2.500000e-01f * _1266828;
int _1266848;
_1266848 = _1041233_1266718.e3;
float _1266864;
_1266864 = _1266862 + _1266863;
float _1266859;
_1266859 = 2.000000e-01f * _1266858;
float _1266860;
_1266860 = _1266852 + _1266859;
float _1266866;
_1266866 = _1266864 + _1266865;
int _1266849;
_1266849 = _1266760 * _1266848;
float _1266868;
_1266868 = _1266866 + _1266867;
int _1266850;
_1266850 = _1266849 + gid_x_1266749;
float val_1266869;
val_1266869 = _1266860 + _1266868;
float* idx_1266851;
idx_1266851 = _1041236_1266721 + _1266850;
*idx_1266851 = val_1266869;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1017905(struct_Img_220118 _1017908_1285867, float* _1017909_1285868, struct_Img_220118 _1017910_1285869, float* _1017911_1285870, struct_Img_220118 _1017912_1285871, float* _1017913_1285872) {
int _1285875;
int p_1285875;
int _1285878;
int p_1285878;
int _1285881;
int p_1285881;
int _1285884;
int p_1285884;
int _1285887;
int p_1285887;
int _1285890;
int p_1285890;
int _1285893;
int p_1285893;
struct_BoundaryMode_220129 bh_upper_1285904;
struct_BoundaryMode_220129 pbh_upper_1285904;
struct_BoundaryMode_220129 bh_upper_1285915;
struct_BoundaryMode_220129 pbh_upper_1285915;
float _1285932;
float p_1285932;
float _1285935;
float p_1285935;
struct_BoundaryMode_220129 bh_upper_1285939;
struct_BoundaryMode_220129 pbh_upper_1285939;
struct_BoundaryMode_220129 bh_upper_1285945;
struct_BoundaryMode_220129 pbh_upper_1285945;
float _1285961;
float p_1285961;
float _1285964;
float p_1285964;
struct_BoundaryMode_220129 bh_upper_1285970;
struct_BoundaryMode_220129 pbh_upper_1285970;
struct_BoundaryMode_220129 bh_upper_1285974;
struct_BoundaryMode_220129 pbh_upper_1285974;
float _1285990;
float p_1285990;
float _1285993;
float p_1285993;
struct_BoundaryMode_220129 bh_upper_1285999;
struct_BoundaryMode_220129 pbh_upper_1285999;
struct_BoundaryMode_220129 bh_upper_1286003;
struct_BoundaryMode_220129 pbh_upper_1286003;
float _1286019;
float p_1286019;
float _1286022;
float p_1286022;
struct_BoundaryMode_220129 bh_upper_1286026;
struct_BoundaryMode_220129 pbh_upper_1286026;
struct_BoundaryMode_220129 bh_upper_1286032;
struct_BoundaryMode_220129 pbh_upper_1286032;
float _1286048;
float p_1286048;
float _1286051;
float p_1286051;
_1285875 = threadIdx_x();
p_1285875 = _1285875;
l1285873: ;
_1285875 = p_1285875;
_1285878 = blockDim_x();
p_1285878 = _1285878;
l1285876: ;
_1285878 = p_1285878;
_1285881 = blockIdx_x();
p_1285881 = _1285881;
l1285879: ;
_1285881 = p_1285881;
_1285884 = threadIdx_y();
p_1285884 = _1285884;
l1285882: ;
_1285884 = p_1285884;
_1285887 = blockDim_y();
p_1285887 = _1285887;
l1285885: ;
_1285887 = p_1285887;
_1285890 = blockIdx_y();
p_1285890 = _1285890;
l1285888: ;
_1285890 = p_1285890;
_1285893 = blockDim_y();
p_1285893 = _1285893;
l1285891: ;
_1285893 = p_1285893;
int _1285895;
_1285895 = _1017910_1285869.e1;
int _1285898;
_1285898 = _1285878 * _1285881;
int _1285894;
_1285894 = _1017912_1285871.e1;
int _1285896;
_1285896 = _1285895 - 128;
int _1285897;
_1285897 = _1285896 + _1285875;
int gid_x_1285899;
gid_x_1285899 = _1285897 + _1285898;
bool _1285900;
_1285900 = _1285894 <= gid_x_1285899;
union variant_220130 _1286088;
_1286088.qs32 = gid_x_1285899;
struct_BoundaryMode_220129 _1286089;
_1286089.e0 = 0;
_1286089.e1 = _1286088;
if (_1285900) goto l1285901; else goto l1286142;
l1286142: ;
pbh_upper_1285904 = _1286089;
goto l1285902;
l1285901: ;
union variant_220130 _1265919_8750;
_1265919_8750.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8752;
_1265920_8752.e0 = 1;
_1265920_8752.e1 = _1265919_8750;
pbh_upper_1285904 = _1265920_8752;
goto l1285902;
l1285902: ;
bh_upper_1285904 = pbh_upper_1285904;
int _1285906;
_1285906 = _1017910_1285869.e2;
int _1285907;
_1285907 = _1285906 - 1;
int _1285905;
_1285905 = _1017912_1285871.e2;
int _1285909;
_1285909 = _1285887 * _1285890;
int _1285908;
_1285908 = _1285907 + _1285884;
int gid_y_1285910;
gid_y_1285910 = _1285908 + _1285909;
union variant_220130 _1286100;
_1286100.qs32 = gid_y_1285910;
bool _1285911;
_1285911 = _1285905 <= gid_y_1285910;
struct_BoundaryMode_220129 _1286101;
_1286101.e0 = 0;
_1286101.e1 = _1286100;
if (_1285911) goto l1285912; else goto l1286141;
l1286141: ;
pbh_upper_1285915 = _1286101;
goto l1285913;
l1285912: ;
union variant_220130 _1265919_8762;
_1265919_8762.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8764;
_1265920_8764.e0 = 1;
_1265920_8764.e1 = _1265919_8762;
pbh_upper_1285915 = _1265920_8764;
goto l1285913;
l1285913: ;
bh_upper_1285915 = pbh_upper_1285915;
unsigned int _1285916;
_1285916 = bh_upper_1285904.e0;
bool _1285917;
_1285917 = _1285916 == 0;
unsigned int _1285918;
_1285918 = bh_upper_1285915.e0;
int _1285924;
_1285924 = _1017912_1285871.e3;
union variant_220130 _1285926;
_1285926 = bh_upper_1285904.e1;
union variant_220130 _1285922;
_1285922 = bh_upper_1285915.e1;
bool _1285919;
_1285919 = _1285918 == 0;
bool _1285920;
_1285920 = _1285917 & _1285919;
if (_1285920) goto l1285921; else goto l1286132;
l1286132: ;
bool _1286133;
_1286133 = _1285916 == 1;
if (_1286133) goto l1286134; else goto l1286136;
l1286136: ;
bool _1286137;
_1286137 = _1285918 == 1;
if (_1286137) goto l1286138; else goto l1286140;
l1286140: ;
// bottom: float r4_1265918_8777;
// bottom: p_1285935 = r4_1265918_8777;
goto l1285933;
l1286138: ;
float c_1286139;
c_1286139 = _1285922.pf32;
p_1285935 = c_1286139;
goto l1285933;
l1286134: ;
float c_1286135;
c_1286135 = _1285926.pf32;
p_1285935 = c_1286135;
goto l1285933;
l1285921: ;
int y_1285923;
y_1285923 = _1285922.qs32;
int x_1285927;
x_1285927 = _1285926.qs32;
int _1285925;
_1285925 = y_1285923 * _1285924;
int _1285928;
_1285928 = _1285925 + x_1285927;
float* idx_1285929;
idx_1285929 = _1017911_1285870 + _1285928;
_1285932 = __ldg(idx_1285929);
p_1285932 = _1285932;
l1285930: ;
_1285932 = p_1285932;
p_1285935 = _1285932;
goto l1285933;
l1285933: ;
_1285935 = p_1285935;
int _1286057;
_1286057 = _1017908_1285867.e3;
int _1286058;
_1286058 = gid_y_1285910 * _1286057;
int _1286059;
_1286059 = _1286058 + gid_x_1285899;
float* idx_1286060;
idx_1286060 = _1017913_1285872 + _1286059;
float _1286061;
_1286061 = *idx_1286060;
if (_1285900) goto l1285936; else goto l1286131;
l1286131: ;
pbh_upper_1285939 = _1286089;
goto l1285937;
l1285936: ;
union variant_220130 _1265919_8779;
_1265919_8779.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8781;
_1265920_8781.e0 = 1;
_1265920_8781.e1 = _1265919_8779;
pbh_upper_1285939 = _1265920_8781;
goto l1285937;
l1285937: ;
bh_upper_1285939 = pbh_upper_1285939;
int _1285940;
_1285940 = -1 + gid_y_1285910;
bool _1285941;
_1285941 = _1285905 <= _1285940;
if (_1285941) goto l1285942; else goto l1286127;
l1286127: ;
union variant_220130 _1286128;
_1286128.qs32 = _1285940;
struct_BoundaryMode_220129 _1286129;
_1286129.e0 = 0;
_1286129.e1 = _1286128;
pbh_upper_1285945 = _1286129;
goto l1285943;
l1285942: ;
union variant_220130 _1265919_8789;
_1265919_8789.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8791;
_1265920_8791.e0 = 1;
_1265920_8791.e1 = _1265919_8789;
pbh_upper_1285945 = _1265920_8791;
goto l1285943;
l1285943: ;
bh_upper_1285945 = pbh_upper_1285945;
union variant_220130 _1285952;
_1285952 = bh_upper_1285945.e1;
unsigned int _1285948;
_1285948 = bh_upper_1285945.e0;
unsigned int _1285946;
_1285946 = bh_upper_1285939.e0;
union variant_220130 _1285955;
_1285955 = bh_upper_1285939.e1;
bool _1285947;
_1285947 = _1285946 == 0;
bool _1285949;
_1285949 = _1285948 == 0;
bool _1285950;
_1285950 = _1285947 & _1285949;
if (_1285950) goto l1285951; else goto l1286118;
l1286118: ;
bool _1286119;
_1286119 = _1285946 == 1;
if (_1286119) goto l1286120; else goto l1286122;
l1286122: ;
bool _1286123;
_1286123 = _1285948 == 1;
if (_1286123) goto l1286124; else goto l1286126;
l1286126: ;
// bottom: float r4_1265918_8803;
// bottom: p_1285964 = r4_1265918_8803;
goto l1285962;
l1286124: ;
float c_1286125;
c_1286125 = _1285952.pf32;
p_1285964 = c_1286125;
goto l1285962;
l1286120: ;
float c_1286121;
c_1286121 = _1285955.pf32;
p_1285964 = c_1286121;
goto l1285962;
l1285951: ;
int y_1285953;
y_1285953 = _1285952.qs32;
int x_1285956;
x_1285956 = _1285955.qs32;
int _1285954;
_1285954 = y_1285953 * _1285924;
int _1285957;
_1285957 = _1285954 + x_1285956;
float* idx_1285958;
idx_1285958 = _1017911_1285870 + _1285957;
_1285961 = __ldg(idx_1285958);
p_1285961 = _1285961;
l1285959: ;
_1285961 = p_1285961;
p_1285964 = _1285961;
goto l1285962;
l1285962: ;
_1285964 = p_1285964;
int _1285965;
_1285965 = -1 + gid_x_1285899;
bool _1285966;
_1285966 = _1285894 <= _1285965;
if (_1285966) goto l1285967; else goto l1286115;
l1286115: ;
union variant_220130 _1286116;
_1286116.qs32 = _1285965;
struct_BoundaryMode_220129 _1286117;
_1286117.e0 = 0;
_1286117.e1 = _1286116;
pbh_upper_1285970 = _1286117;
goto l1285968;
l1285967: ;
union variant_220130 _1265919_8808;
_1265919_8808.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8810;
_1265920_8810.e0 = 1;
_1265920_8810.e1 = _1265919_8808;
pbh_upper_1285970 = _1265920_8810;
goto l1285968;
l1285968: ;
bh_upper_1285970 = pbh_upper_1285970;
if (_1285911) goto l1285971; else goto l1286114;
l1286114: ;
pbh_upper_1285974 = _1286101;
goto l1285972;
l1285971: ;
union variant_220130 _1265919_8814;
_1265919_8814.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8816;
_1265920_8816.e0 = 1;
_1265920_8816.e1 = _1265919_8814;
pbh_upper_1285974 = _1265920_8816;
goto l1285972;
l1285972: ;
bh_upper_1285974 = pbh_upper_1285974;
union variant_220130 _1285981;
_1285981 = bh_upper_1285974.e1;
union variant_220130 _1285984;
_1285984 = bh_upper_1285970.e1;
unsigned int _1285975;
_1285975 = bh_upper_1285970.e0;
unsigned int _1285977;
_1285977 = bh_upper_1285974.e0;
bool _1285976;
_1285976 = _1285975 == 0;
bool _1285978;
_1285978 = _1285977 == 0;
bool _1285979;
_1285979 = _1285976 & _1285978;
if (_1285979) goto l1285980; else goto l1286105;
l1286105: ;
bool _1286106;
_1286106 = _1285975 == 1;
if (_1286106) goto l1286107; else goto l1286109;
l1286109: ;
bool _1286110;
_1286110 = _1285977 == 1;
if (_1286110) goto l1286111; else goto l1286113;
l1286113: ;
// bottom: float r4_1265918_8828;
// bottom: p_1285993 = r4_1265918_8828;
goto l1285991;
l1286111: ;
float c_1286112;
c_1286112 = _1285981.pf32;
p_1285993 = c_1286112;
goto l1285991;
l1286107: ;
float c_1286108;
c_1286108 = _1285984.pf32;
p_1285993 = c_1286108;
goto l1285991;
l1285980: ;
int y_1285982;
y_1285982 = _1285981.qs32;
int x_1285985;
x_1285985 = _1285984.qs32;
int _1285983;
_1285983 = y_1285982 * _1285924;
int _1285986;
_1285986 = _1285983 + x_1285985;
float* idx_1285987;
idx_1285987 = _1017911_1285870 + _1285986;
_1285990 = __ldg(idx_1285987);
p_1285990 = _1285990;
l1285988: ;
_1285990 = p_1285990;
p_1285993 = _1285990;
goto l1285991;
l1285991: ;
_1285993 = p_1285993;
int _1285994;
_1285994 = 1 + gid_x_1285899;
bool _1285995;
_1285995 = _1285894 <= _1285994;
if (_1285995) goto l1285996; else goto l1286102;
l1286102: ;
union variant_220130 _1286103;
_1286103.qs32 = _1285994;
struct_BoundaryMode_220129 _1286104;
_1286104.e0 = 0;
_1286104.e1 = _1286103;
pbh_upper_1285999 = _1286104;
goto l1285997;
l1285996: ;
union variant_220130 _1265919_8833;
_1265919_8833.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8835;
_1265920_8835.e0 = 1;
_1265920_8835.e1 = _1265919_8833;
pbh_upper_1285999 = _1265920_8835;
goto l1285997;
l1285997: ;
bh_upper_1285999 = pbh_upper_1285999;
if (_1285911) goto l1286000; else goto l1286099;
l1286099: ;
pbh_upper_1286003 = _1286101;
goto l1286001;
l1286000: ;
union variant_220130 _1265919_8839;
_1265919_8839.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8841;
_1265920_8841.e0 = 1;
_1265920_8841.e1 = _1265919_8839;
pbh_upper_1286003 = _1265920_8841;
goto l1286001;
l1286001: ;
bh_upper_1286003 = pbh_upper_1286003;
union variant_220130 _1286010;
_1286010 = bh_upper_1286003.e1;
unsigned int _1286004;
_1286004 = bh_upper_1285999.e0;
union variant_220130 _1286013;
_1286013 = bh_upper_1285999.e1;
unsigned int _1286006;
_1286006 = bh_upper_1286003.e0;
bool _1286005;
_1286005 = _1286004 == 0;
bool _1286007;
_1286007 = _1286006 == 0;
bool _1286008;
_1286008 = _1286005 & _1286007;
if (_1286008) goto l1286009; else goto l1286090;
l1286090: ;
bool _1286091;
_1286091 = _1286004 == 1;
if (_1286091) goto l1286092; else goto l1286094;
l1286094: ;
bool _1286095;
_1286095 = _1286006 == 1;
if (_1286095) goto l1286096; else goto l1286098;
l1286098: ;
// bottom: float r4_1265918_8853;
// bottom: p_1286022 = r4_1265918_8853;
goto l1286020;
l1286096: ;
float c_1286097;
c_1286097 = _1286010.pf32;
p_1286022 = c_1286097;
goto l1286020;
l1286092: ;
float c_1286093;
c_1286093 = _1286013.pf32;
p_1286022 = c_1286093;
goto l1286020;
l1286009: ;
int x_1286014;
x_1286014 = _1286013.qs32;
int y_1286011;
y_1286011 = _1286010.qs32;
int _1286012;
_1286012 = y_1286011 * _1285924;
int _1286015;
_1286015 = _1286012 + x_1286014;
float* idx_1286016;
idx_1286016 = _1017911_1285870 + _1286015;
_1286019 = __ldg(idx_1286016);
p_1286019 = _1286019;
l1286017: ;
_1286019 = p_1286019;
p_1286022 = _1286019;
goto l1286020;
l1286020: ;
_1286022 = p_1286022;
if (_1285900) goto l1286023; else goto l1286087;
l1286087: ;
pbh_upper_1286026 = _1286089;
goto l1286024;
l1286023: ;
union variant_220130 _1265919_8854;
_1265919_8854.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8856;
_1265920_8856.e0 = 1;
_1265920_8856.e1 = _1265919_8854;
pbh_upper_1286026 = _1265920_8856;
goto l1286024;
l1286024: ;
bh_upper_1286026 = pbh_upper_1286026;
int _1286027;
_1286027 = 1 + gid_y_1285910;
bool _1286028;
_1286028 = _1285905 <= _1286027;
if (_1286028) goto l1286029; else goto l1286084;
l1286084: ;
union variant_220130 _1286085;
_1286085.qs32 = _1286027;
struct_BoundaryMode_220129 _1286086;
_1286086.e0 = 0;
_1286086.e1 = _1286085;
pbh_upper_1286032 = _1286086;
goto l1286030;
l1286029: ;
union variant_220130 _1265919_8864;
_1265919_8864.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8866;
_1265920_8866.e0 = 1;
_1265920_8866.e1 = _1265919_8864;
pbh_upper_1286032 = _1265920_8866;
goto l1286030;
l1286030: ;
bh_upper_1286032 = pbh_upper_1286032;
union variant_220130 _1286039;
_1286039 = bh_upper_1286032.e1;
unsigned int _1286035;
_1286035 = bh_upper_1286032.e0;
union variant_220130 _1286042;
_1286042 = bh_upper_1286026.e1;
bool _1286036;
_1286036 = _1286035 == 0;
unsigned int _1286033;
_1286033 = bh_upper_1286026.e0;
bool _1286034;
_1286034 = _1286033 == 0;
bool _1286037;
_1286037 = _1286034 & _1286036;
if (_1286037) goto l1286038; else goto l1286075;
l1286075: ;
bool _1286076;
_1286076 = _1286033 == 1;
if (_1286076) goto l1286077; else goto l1286079;
l1286079: ;
bool _1286080;
_1286080 = _1286035 == 1;
if (_1286080) goto l1286081; else goto l1286083;
l1286083: ;
// bottom: float r4_1265918_8878;
// bottom: p_1286051 = r4_1265918_8878;
goto l1286049;
l1286081: ;
float c_1286082;
c_1286082 = _1286039.pf32;
p_1286051 = c_1286082;
goto l1286049;
l1286077: ;
float c_1286078;
c_1286078 = _1286042.pf32;
p_1286051 = c_1286078;
goto l1286049;
l1286038: ;
int x_1286043;
x_1286043 = _1286042.qs32;
int y_1286040;
y_1286040 = _1286039.qs32;
int _1286041;
_1286041 = y_1286040 * _1285924;
int _1286044;
_1286044 = _1286041 + x_1286043;
float* idx_1286045;
idx_1286045 = _1017911_1285870 + _1286044;
_1286048 = __ldg(idx_1286045);
p_1286048 = _1286048;
l1286046: ;
_1286048 = p_1286048;
p_1286051 = _1286048;
goto l1286049;
l1286049: ;
_1286051 = p_1286051;
int _1286052;
_1286052 = _1017910_1285869.e3;
float _1286065;
_1286065 = 2.500000e-01f * _1285964;
float _1286069;
_1286069 = 2.500000e-01f * _1286022;
int _1286053;
_1286053 = gid_y_1285910 * _1286052;
int _1286054;
_1286054 = _1286053 + gid_x_1285899;
float _1286056;
_1286056 = 2.000000e-01f * _1285935;
float _1286071;
_1286071 = 2.500000e-01f * _1286051;
float _1286066;
_1286066 = 0.000000e+00f + _1286065;
float _1286062;
_1286062 = _1286061;
float _1286067;
_1286067 = 2.500000e-01f * _1285993;
float* idx_1286055;
idx_1286055 = _1017909_1285868 + _1286054;
float _1286068;
_1286068 = _1286066 + _1286067;
float _1286063;
_1286063 = 2.000000e-01f * _1286062;
float _1286070;
_1286070 = _1286068 + _1286069;
float _1286064;
_1286064 = _1286056 + _1286063;
float _1286072;
_1286072 = _1286070 + _1286071;
float val_1286073;
val_1286073 = _1286064 + _1286072;
*idx_1286055 = val_1286073;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1002219(struct_Img_220118 _1002222_1284062, float* _1002223_1284063, struct_Img_220118 _1002224_1284064, float* _1002225_1284065, float* _1002226_1284066, struct_Img_220118 _1002227_1284067) {
int _1284070;
int p_1284070;
int _1284073;
int p_1284073;
int _1284076;
int p_1284076;
int _1284079;
int p_1284079;
int _1284082;
int p_1284082;
int _1284085;
int p_1284085;
int _1284088;
int p_1284088;
struct_BoundaryMode_220129 bh_upper_1284099;
struct_BoundaryMode_220129 pbh_upper_1284099;
float _1284114;
float p_1284114;
float _1284117;
float p_1284117;
struct_BoundaryMode_220129 bh_upper_1284123;
struct_BoundaryMode_220129 pbh_upper_1284123;
float _1284135;
float p_1284135;
float _1284138;
float p_1284138;
struct_BoundaryMode_220129 bh_upper_1284142;
struct_BoundaryMode_220129 pbh_upper_1284142;
float _1284154;
float p_1284154;
float _1284157;
float p_1284157;
struct_BoundaryMode_220129 bh_upper_1284161;
struct_BoundaryMode_220129 pbh_upper_1284161;
float _1284173;
float p_1284173;
float _1284176;
float p_1284176;
struct_BoundaryMode_220129 bh_upper_1284182;
struct_BoundaryMode_220129 pbh_upper_1284182;
float _1284194;
float p_1284194;
float _1284197;
float p_1284197;
_1284070 = threadIdx_x();
p_1284070 = _1284070;
l1284068: ;
_1284070 = p_1284070;
_1284073 = blockDim_x();
p_1284073 = _1284073;
l1284071: ;
_1284073 = p_1284073;
_1284076 = blockIdx_x();
p_1284076 = _1284076;
l1284074: ;
_1284076 = p_1284076;
_1284079 = threadIdx_y();
p_1284079 = _1284079;
l1284077: ;
_1284079 = p_1284079;
_1284082 = blockDim_y();
p_1284082 = _1284082;
l1284080: ;
_1284082 = p_1284082;
_1284085 = blockIdx_y();
p_1284085 = _1284085;
l1284083: ;
_1284085 = p_1284085;
_1284088 = blockDim_y();
p_1284088 = _1284088;
l1284086: ;
_1284088 = p_1284088;
int _1284093;
_1284093 = _1284082 * _1284085;
int _1284090;
_1284090 = _1002227_1284067.e2;
int _1284089;
_1284089 = _1002222_1284062.e2;
int _1284091;
_1284091 = _1284090 - 1;
int _1284092;
_1284092 = _1284091 + _1284079;
int gid_y_1284094;
gid_y_1284094 = _1284092 + _1284093;
bool _1284095;
_1284095 = _1284089 <= gid_y_1284094;
union variant_220130 _1284237;
_1284237.qs32 = gid_y_1284094;
struct_BoundaryMode_220129 _1284238;
_1284238.e0 = 0;
_1284238.e1 = _1284237;
if (_1284095) goto l1284096; else goto l1284259;
l1284259: ;
pbh_upper_1284099 = _1284238;
goto l1284097;
l1284096: ;
union variant_220130 _1265919_8893;
_1265919_8893.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8895;
_1265920_8895.e0 = 1;
_1265920_8895.e1 = _1265919_8893;
pbh_upper_1284099 = _1265920_8895;
goto l1284097;
l1284097: ;
bh_upper_1284099 = pbh_upper_1284099;
union variant_220130 _1284103;
_1284103 = bh_upper_1284099.e1;
int _1284107;
_1284107 = _1284073 * _1284076;
int gid_x_1284108;
gid_x_1284108 = _1284070 + _1284107;
unsigned int _1284100;
_1284100 = bh_upper_1284099.e0;
int _1284105;
_1284105 = _1002222_1284062.e3;
bool _1284101;
_1284101 = _1284100 == 0;
if (_1284101) goto l1284102; else goto l1284254;
l1284254: ;
bool _1284255;
_1284255 = _1284100 == 1;
if (_1284255) goto l1284256; else goto l1284258;
l1284258: ;
// bottom: float r4_1265918_8904;
// bottom: p_1284117 = r4_1265918_8904;
goto l1284115;
l1284256: ;
float c_1284257;
c_1284257 = _1284103.pf32;
p_1284117 = c_1284257;
goto l1284115;
l1284102: ;
int y_1284104;
y_1284104 = _1284103.qs32;
int _1284106;
_1284106 = y_1284104 * _1284105;
int _1284109;
_1284109 = _1284106 + gid_x_1284108;
int _1284110;
_1284110 = 128 + _1284109;
float* idx_1284111;
idx_1284111 = _1002223_1284063 + _1284110;
_1284114 = __ldg(idx_1284111);
p_1284114 = _1284114;
l1284112: ;
_1284114 = p_1284114;
p_1284117 = _1284114;
goto l1284115;
l1284115: ;
_1284117 = p_1284117;
int _1284118;
_1284118 = -1 + gid_y_1284094;
bool _1284119;
_1284119 = _1284089 <= _1284118;
int _1284204;
_1284204 = _1002224_1284064.e3;
int _1284205;
_1284205 = gid_y_1284094 * _1284204;
int _1284206;
_1284206 = _1284205 + gid_x_1284108;
int _1284207;
_1284207 = 128 + _1284206;
float* idx_1284208;
idx_1284208 = _1002226_1284066 + _1284207;
float _1284209;
_1284209 = *idx_1284208;
if (_1284119) goto l1284120; else goto l1284251;
l1284251: ;
union variant_220130 _1284252;
_1284252.qs32 = _1284118;
struct_BoundaryMode_220129 _1284253;
_1284253.e0 = 0;
_1284253.e1 = _1284252;
pbh_upper_1284123 = _1284253;
goto l1284121;
l1284120: ;
union variant_220130 _1265919_8912;
_1265919_8912.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8914;
_1265920_8914.e0 = 1;
_1265920_8914.e1 = _1265919_8912;
pbh_upper_1284123 = _1265920_8914;
goto l1284121;
l1284121: ;
bh_upper_1284123 = pbh_upper_1284123;
union variant_220130 _1284127;
_1284127 = bh_upper_1284123.e1;
unsigned int _1284124;
_1284124 = bh_upper_1284123.e0;
bool _1284125;
_1284125 = _1284124 == 0;
if (_1284125) goto l1284126; else goto l1284245;
l1284245: ;
bool _1284246;
_1284246 = _1284124 == 1;
if (_1284246) goto l1284247; else goto l1284249;
l1284249: ;
// bottom: float r4_1265918_8922;
// bottom: p_1284138 = r4_1265918_8922;
goto l1284136;
l1284247: ;
float c_1284248;
c_1284248 = _1284127.pf32;
p_1284138 = c_1284248;
goto l1284136;
l1284126: ;
int y_1284128;
y_1284128 = _1284127.qs32;
int _1284129;
_1284129 = y_1284128 * _1284105;
int _1284130;
_1284130 = _1284129 + gid_x_1284108;
int _1284131;
_1284131 = 128 + _1284130;
float* idx_1284132;
idx_1284132 = _1002223_1284063 + _1284131;
_1284135 = __ldg(idx_1284132);
p_1284135 = _1284135;
l1284133: ;
_1284135 = p_1284135;
p_1284138 = _1284135;
goto l1284136;
l1284136: ;
_1284138 = p_1284138;
if (_1284095) goto l1284139; else goto l1284244;
l1284244: ;
pbh_upper_1284142 = _1284238;
goto l1284140;
l1284139: ;
union variant_220130 _1265919_8924;
_1265919_8924.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8926;
_1265920_8926.e0 = 1;
_1265920_8926.e1 = _1265919_8924;
pbh_upper_1284142 = _1265920_8926;
goto l1284140;
l1284140: ;
bh_upper_1284142 = pbh_upper_1284142;
union variant_220130 _1284146;
_1284146 = bh_upper_1284142.e1;
unsigned int _1284143;
_1284143 = bh_upper_1284142.e0;
bool _1284144;
_1284144 = _1284143 == 0;
if (_1284144) goto l1284145; else goto l1284239;
l1284239: ;
bool _1284240;
_1284240 = _1284143 == 1;
if (_1284240) goto l1284241; else goto l1284243;
l1284243: ;
// bottom: float r4_1265918_8934;
// bottom: p_1284157 = r4_1265918_8934;
goto l1284155;
l1284241: ;
float c_1284242;
c_1284242 = _1284146.pf32;
p_1284157 = c_1284242;
goto l1284155;
l1284145: ;
int y_1284147;
y_1284147 = _1284146.qs32;
int _1284148;
_1284148 = y_1284147 * _1284105;
int _1284149;
_1284149 = _1284148 + gid_x_1284108;
int _1284150;
_1284150 = 127 + _1284149;
float* idx_1284151;
idx_1284151 = _1002223_1284063 + _1284150;
_1284154 = __ldg(idx_1284151);
p_1284154 = _1284154;
l1284152: ;
_1284154 = p_1284154;
p_1284157 = _1284154;
goto l1284155;
l1284155: ;
_1284157 = p_1284157;
if (_1284095) goto l1284158; else goto l1284236;
l1284236: ;
pbh_upper_1284161 = _1284238;
goto l1284159;
l1284158: ;
union variant_220130 _1265919_8936;
_1265919_8936.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8938;
_1265920_8938.e0 = 1;
_1265920_8938.e1 = _1265919_8936;
pbh_upper_1284161 = _1265920_8938;
goto l1284159;
l1284159: ;
bh_upper_1284161 = pbh_upper_1284161;
union variant_220130 _1284165;
_1284165 = bh_upper_1284161.e1;
unsigned int _1284162;
_1284162 = bh_upper_1284161.e0;
bool _1284163;
_1284163 = _1284162 == 0;
if (_1284163) goto l1284164; else goto l1284231;
l1284231: ;
bool _1284232;
_1284232 = _1284162 == 1;
if (_1284232) goto l1284233; else goto l1284235;
l1284235: ;
// bottom: float r4_1265918_8946;
// bottom: p_1284176 = r4_1265918_8946;
goto l1284174;
l1284233: ;
float c_1284234;
c_1284234 = _1284165.pf32;
p_1284176 = c_1284234;
goto l1284174;
l1284164: ;
int y_1284166;
y_1284166 = _1284165.qs32;
int _1284167;
_1284167 = y_1284166 * _1284105;
int _1284168;
_1284168 = _1284167 + gid_x_1284108;
int _1284169;
_1284169 = 129 + _1284168;
float* idx_1284170;
idx_1284170 = _1002223_1284063 + _1284169;
_1284173 = __ldg(idx_1284170);
p_1284173 = _1284173;
l1284171: ;
_1284173 = p_1284173;
p_1284176 = _1284173;
goto l1284174;
l1284174: ;
_1284176 = p_1284176;
int _1284177;
_1284177 = 1 + gid_y_1284094;
bool _1284178;
_1284178 = _1284089 <= _1284177;
if (_1284178) goto l1284179; else goto l1284228;
l1284228: ;
union variant_220130 _1284229;
_1284229.qs32 = _1284177;
struct_BoundaryMode_220129 _1284230;
_1284230.e0 = 0;
_1284230.e1 = _1284229;
pbh_upper_1284182 = _1284230;
goto l1284180;
l1284179: ;
union variant_220130 _1265919_8952;
_1265919_8952.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8954;
_1265920_8954.e0 = 1;
_1265920_8954.e1 = _1265919_8952;
pbh_upper_1284182 = _1265920_8954;
goto l1284180;
l1284180: ;
bh_upper_1284182 = pbh_upper_1284182;
union variant_220130 _1284186;
_1284186 = bh_upper_1284182.e1;
unsigned int _1284183;
_1284183 = bh_upper_1284182.e0;
bool _1284184;
_1284184 = _1284183 == 0;
if (_1284184) goto l1284185; else goto l1284223;
l1284223: ;
bool _1284224;
_1284224 = _1284183 == 1;
if (_1284224) goto l1284225; else goto l1284227;
l1284227: ;
// bottom: float r4_1265918_8962;
// bottom: p_1284197 = r4_1265918_8962;
goto l1284195;
l1284225: ;
float c_1284226;
c_1284226 = _1284186.pf32;
p_1284197 = c_1284226;
goto l1284195;
l1284185: ;
int y_1284187;
y_1284187 = _1284186.qs32;
int _1284188;
_1284188 = y_1284187 * _1284105;
int _1284189;
_1284189 = _1284188 + gid_x_1284108;
int _1284190;
_1284190 = 128 + _1284189;
float* idx_1284191;
idx_1284191 = _1002223_1284063 + _1284190;
_1284194 = __ldg(idx_1284191);
p_1284194 = _1284194;
l1284192: ;
_1284194 = p_1284194;
p_1284197 = _1284194;
goto l1284195;
l1284195: ;
_1284197 = p_1284197;
int _1284198;
_1284198 = _1002227_1284067.e3;
float _1284217;
_1284217 = 2.500000e-01f * _1284176;
float _1284210;
_1284210 = _1284209;
float _1284215;
_1284215 = 2.500000e-01f * _1284157;
float _1284211;
_1284211 = 2.000000e-01f * _1284210;
int _1284199;
_1284199 = gid_y_1284094 * _1284198;
float _1284213;
_1284213 = 2.500000e-01f * _1284138;
float _1284219;
_1284219 = 2.500000e-01f * _1284197;
float _1284203;
_1284203 = 2.000000e-01f * _1284117;
int _1284200;
_1284200 = _1284199 + gid_x_1284108;
float _1284212;
_1284212 = _1284203 + _1284211;
float _1284214;
_1284214 = 0.000000e+00f + _1284213;
int _1284201;
_1284201 = 128 + _1284200;
float _1284216;
_1284216 = _1284214 + _1284215;
float* idx_1284202;
idx_1284202 = _1002225_1284065 + _1284201;
float _1284218;
_1284218 = _1284216 + _1284217;
float _1284220;
_1284220 = _1284218 + _1284219;
float val_1284221;
val_1284221 = _1284212 + _1284220;
*idx_1284202 = val_1284221;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1038843(struct_Img_220118 _1038846_1287138, struct_Img_220118 _1038847_1287139, float* _1038848_1287140, struct_Img_220118 _1038849_1287141, float* _1038850_1287142, float* _1038851_1287143) {
int _1287146;
int p_1287146;
int _1287149;
int p_1287149;
int _1287152;
int p_1287152;
int _1287155;
int p_1287155;
int _1287158;
int p_1287158;
int _1287161;
int p_1287161;
int _1287164;
int p_1287164;
struct_BoundaryMode_220129 bh_lower_1287171;
struct_BoundaryMode_220129 pbh_lower_1287171;
struct_BoundaryMode_220129 bh_upper_1287182;
struct_BoundaryMode_220129 pbh_upper_1287182;
float _1287199;
float p_1287199;
float _1287202;
float p_1287202;
struct_BoundaryMode_220129 bh_lower_1287206;
struct_BoundaryMode_220129 pbh_lower_1287206;
struct_BoundaryMode_220129 bh_upper_1287212;
struct_BoundaryMode_220129 pbh_upper_1287212;
float _1287228;
float p_1287228;
float _1287231;
float p_1287231;
struct_BoundaryMode_220129 bh_lower_1287237;
struct_BoundaryMode_220129 pbh_lower_1287237;
struct_BoundaryMode_220129 bh_upper_1287241;
struct_BoundaryMode_220129 pbh_upper_1287241;
float _1287257;
float p_1287257;
float _1287260;
float p_1287260;
struct_BoundaryMode_220129 bh_lower_1287266;
struct_BoundaryMode_220129 pbh_lower_1287266;
struct_BoundaryMode_220129 bh_upper_1287270;
struct_BoundaryMode_220129 pbh_upper_1287270;
float _1287286;
float p_1287286;
float _1287289;
float p_1287289;
struct_BoundaryMode_220129 bh_lower_1287293;
struct_BoundaryMode_220129 pbh_lower_1287293;
struct_BoundaryMode_220129 bh_upper_1287299;
struct_BoundaryMode_220129 pbh_upper_1287299;
float _1287315;
float p_1287315;
float _1287318;
float p_1287318;
_1287146 = threadIdx_x();
p_1287146 = _1287146;
l1287144: ;
_1287146 = p_1287146;
_1287149 = blockDim_x();
p_1287149 = _1287149;
l1287147: ;
_1287149 = p_1287149;
_1287152 = blockIdx_x();
p_1287152 = _1287152;
l1287150: ;
_1287152 = p_1287152;
_1287155 = threadIdx_y();
p_1287155 = _1287155;
l1287153: ;
_1287155 = p_1287155;
_1287158 = blockDim_y();
p_1287158 = _1287158;
l1287156: ;
_1287158 = p_1287158;
_1287161 = blockIdx_y();
p_1287161 = _1287161;
l1287159: ;
_1287161 = p_1287161;
_1287164 = blockDim_y();
p_1287164 = _1287164;
l1287162: ;
_1287164 = p_1287164;
int _1287165;
_1287165 = _1287149 * _1287152;
int gid_x_1287166;
gid_x_1287166 = _1287146 + _1287165;
union variant_220130 _1287355;
_1287355.qs32 = gid_x_1287166;
bool _1287167;
_1287167 = gid_x_1287166 < 0;
struct_BoundaryMode_220129 _1287356;
_1287356.e0 = 0;
_1287356.e1 = _1287355;
if (_1287167) goto l1287168; else goto l1287409;
l1287409: ;
pbh_lower_1287171 = _1287356;
goto l1287169;
l1287168: ;
union variant_220130 _1265919_8977;
_1265919_8977.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8979;
_1265920_8979.e0 = 1;
_1265920_8979.e1 = _1265919_8977;
pbh_lower_1287171 = _1265920_8979;
goto l1287169;
l1287169: ;
bh_lower_1287171 = pbh_lower_1287171;
int _1287173;
_1287173 = _1038847_1287139.e2;
int _1287172;
_1287172 = _1038846_1287138.e2;
int _1287174;
_1287174 = _1287173 - 1;
int _1287175;
_1287175 = _1287174 + _1287155;
int _1287176;
_1287176 = _1287158 * _1287161;
int gid_y_1287177;
gid_y_1287177 = _1287175 + _1287176;
bool _1287178;
_1287178 = _1287172 <= gid_y_1287177;
union variant_220130 _1287367;
_1287367.qs32 = gid_y_1287177;
struct_BoundaryMode_220129 _1287368;
_1287368.e0 = 0;
_1287368.e1 = _1287367;
if (_1287178) goto l1287179; else goto l1287408;
l1287408: ;
pbh_upper_1287182 = _1287368;
goto l1287180;
l1287179: ;
union variant_220130 _1265919_8989;
_1265919_8989.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_8991;
_1265920_8991.e0 = 1;
_1265920_8991.e1 = _1265919_8989;
pbh_upper_1287182 = _1265920_8991;
goto l1287180;
l1287180: ;
bh_upper_1287182 = pbh_upper_1287182;
unsigned int _1287185;
_1287185 = bh_upper_1287182.e0;
unsigned int _1287183;
_1287183 = bh_lower_1287171.e0;
int _1287191;
_1287191 = _1038846_1287138.e3;
union variant_220130 _1287193;
_1287193 = bh_lower_1287171.e1;
bool _1287186;
_1287186 = _1287185 == 0;
bool _1287184;
_1287184 = _1287183 == 0;
union variant_220130 _1287189;
_1287189 = bh_upper_1287182.e1;
bool _1287187;
_1287187 = _1287184 & _1287186;
if (_1287187) goto l1287188; else goto l1287399;
l1287399: ;
bool _1287400;
_1287400 = _1287183 == 1;
if (_1287400) goto l1287401; else goto l1287403;
l1287403: ;
bool _1287404;
_1287404 = _1287185 == 1;
if (_1287404) goto l1287405; else goto l1287407;
l1287407: ;
// bottom: float r4_1265918_9004;
// bottom: p_1287202 = r4_1265918_9004;
goto l1287200;
l1287405: ;
float c_1287406;
c_1287406 = _1287189.pf32;
p_1287202 = c_1287406;
goto l1287200;
l1287401: ;
float c_1287402;
c_1287402 = _1287193.pf32;
p_1287202 = c_1287402;
goto l1287200;
l1287188: ;
int y_1287190;
y_1287190 = _1287189.qs32;
int x_1287194;
x_1287194 = _1287193.qs32;
int _1287192;
_1287192 = y_1287190 * _1287191;
int _1287195;
_1287195 = _1287192 + x_1287194;
float* idx_1287196;
idx_1287196 = _1038848_1287140 + _1287195;
_1287199 = __ldg(idx_1287196);
p_1287199 = _1287199;
l1287197: ;
_1287199 = p_1287199;
p_1287202 = _1287199;
goto l1287200;
l1287200: ;
_1287202 = p_1287202;
int _1287324;
_1287324 = _1038849_1287141.e3;
int _1287325;
_1287325 = gid_y_1287177 * _1287324;
int _1287326;
_1287326 = _1287325 + gid_x_1287166;
float* idx_1287327;
idx_1287327 = _1038851_1287143 + _1287326;
float _1287328;
_1287328 = *idx_1287327;
if (_1287167) goto l1287203; else goto l1287398;
l1287398: ;
pbh_lower_1287206 = _1287356;
goto l1287204;
l1287203: ;
union variant_220130 _1265919_9006;
_1265919_9006.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9008;
_1265920_9008.e0 = 1;
_1265920_9008.e1 = _1265919_9006;
pbh_lower_1287206 = _1265920_9008;
goto l1287204;
l1287204: ;
bh_lower_1287206 = pbh_lower_1287206;
int _1287207;
_1287207 = -1 + gid_y_1287177;
bool _1287208;
_1287208 = _1287172 <= _1287207;
if (_1287208) goto l1287209; else goto l1287394;
l1287394: ;
union variant_220130 _1287395;
_1287395.qs32 = _1287207;
struct_BoundaryMode_220129 _1287396;
_1287396.e0 = 0;
_1287396.e1 = _1287395;
pbh_upper_1287212 = _1287396;
goto l1287210;
l1287209: ;
union variant_220130 _1265919_9016;
_1265919_9016.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9018;
_1265920_9018.e0 = 1;
_1265920_9018.e1 = _1265919_9016;
pbh_upper_1287212 = _1265920_9018;
goto l1287210;
l1287210: ;
bh_upper_1287212 = pbh_upper_1287212;
unsigned int _1287213;
_1287213 = bh_lower_1287206.e0;
unsigned int _1287215;
_1287215 = bh_upper_1287212.e0;
union variant_220130 _1287219;
_1287219 = bh_upper_1287212.e1;
bool _1287216;
_1287216 = _1287215 == 0;
union variant_220130 _1287222;
_1287222 = bh_lower_1287206.e1;
bool _1287214;
_1287214 = _1287213 == 0;
bool _1287217;
_1287217 = _1287214 & _1287216;
if (_1287217) goto l1287218; else goto l1287385;
l1287385: ;
bool _1287386;
_1287386 = _1287213 == 1;
if (_1287386) goto l1287387; else goto l1287389;
l1287389: ;
bool _1287390;
_1287390 = _1287215 == 1;
if (_1287390) goto l1287391; else goto l1287393;
l1287393: ;
// bottom: float r4_1265918_9030;
// bottom: p_1287231 = r4_1265918_9030;
goto l1287229;
l1287391: ;
float c_1287392;
c_1287392 = _1287219.pf32;
p_1287231 = c_1287392;
goto l1287229;
l1287387: ;
float c_1287388;
c_1287388 = _1287222.pf32;
p_1287231 = c_1287388;
goto l1287229;
l1287218: ;
int x_1287223;
x_1287223 = _1287222.qs32;
int y_1287220;
y_1287220 = _1287219.qs32;
int _1287221;
_1287221 = y_1287220 * _1287191;
int _1287224;
_1287224 = _1287221 + x_1287223;
float* idx_1287225;
idx_1287225 = _1038848_1287140 + _1287224;
_1287228 = __ldg(idx_1287225);
p_1287228 = _1287228;
l1287226: ;
_1287228 = p_1287228;
p_1287231 = _1287228;
goto l1287229;
l1287229: ;
_1287231 = p_1287231;
int _1287232;
_1287232 = -1 + gid_x_1287166;
bool _1287233;
_1287233 = _1287232 < 0;
if (_1287233) goto l1287234; else goto l1287382;
l1287382: ;
union variant_220130 _1287383;
_1287383.qs32 = _1287232;
struct_BoundaryMode_220129 _1287384;
_1287384.e0 = 0;
_1287384.e1 = _1287383;
pbh_lower_1287237 = _1287384;
goto l1287235;
l1287234: ;
union variant_220130 _1265919_9036;
_1265919_9036.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9038;
_1265920_9038.e0 = 1;
_1265920_9038.e1 = _1265919_9036;
pbh_lower_1287237 = _1265920_9038;
goto l1287235;
l1287235: ;
bh_lower_1287237 = pbh_lower_1287237;
if (_1287178) goto l1287238; else goto l1287381;
l1287381: ;
pbh_upper_1287241 = _1287368;
goto l1287239;
l1287238: ;
union variant_220130 _1265919_9042;
_1265919_9042.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9044;
_1265920_9044.e0 = 1;
_1265920_9044.e1 = _1265919_9042;
pbh_upper_1287241 = _1265920_9044;
goto l1287239;
l1287239: ;
bh_upper_1287241 = pbh_upper_1287241;
union variant_220130 _1287251;
_1287251 = bh_lower_1287237.e1;
union variant_220130 _1287248;
_1287248 = bh_upper_1287241.e1;
unsigned int _1287242;
_1287242 = bh_lower_1287237.e0;
bool _1287243;
_1287243 = _1287242 == 0;
unsigned int _1287244;
_1287244 = bh_upper_1287241.e0;
bool _1287245;
_1287245 = _1287244 == 0;
bool _1287246;
_1287246 = _1287243 & _1287245;
if (_1287246) goto l1287247; else goto l1287372;
l1287372: ;
bool _1287373;
_1287373 = _1287242 == 1;
if (_1287373) goto l1287374; else goto l1287376;
l1287376: ;
bool _1287377;
_1287377 = _1287244 == 1;
if (_1287377) goto l1287378; else goto l1287380;
l1287380: ;
// bottom: float r4_1265918_9056;
// bottom: p_1287260 = r4_1265918_9056;
goto l1287258;
l1287378: ;
float c_1287379;
c_1287379 = _1287248.pf32;
p_1287260 = c_1287379;
goto l1287258;
l1287374: ;
float c_1287375;
c_1287375 = _1287251.pf32;
p_1287260 = c_1287375;
goto l1287258;
l1287247: ;
int x_1287252;
x_1287252 = _1287251.qs32;
int y_1287249;
y_1287249 = _1287248.qs32;
int _1287250;
_1287250 = y_1287249 * _1287191;
int _1287253;
_1287253 = _1287250 + x_1287252;
float* idx_1287254;
idx_1287254 = _1038848_1287140 + _1287253;
_1287257 = __ldg(idx_1287254);
p_1287257 = _1287257;
l1287255: ;
_1287257 = p_1287257;
p_1287260 = _1287257;
goto l1287258;
l1287258: ;
_1287260 = p_1287260;
int _1287261;
_1287261 = 1 + gid_x_1287166;
bool _1287262;
_1287262 = _1287261 < 0;
if (_1287262) goto l1287263; else goto l1287369;
l1287369: ;
union variant_220130 _1287370;
_1287370.qs32 = _1287261;
struct_BoundaryMode_220129 _1287371;
_1287371.e0 = 0;
_1287371.e1 = _1287370;
pbh_lower_1287266 = _1287371;
goto l1287264;
l1287263: ;
union variant_220130 _1265919_9062;
_1265919_9062.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9064;
_1265920_9064.e0 = 1;
_1265920_9064.e1 = _1265919_9062;
pbh_lower_1287266 = _1265920_9064;
goto l1287264;
l1287264: ;
bh_lower_1287266 = pbh_lower_1287266;
if (_1287178) goto l1287267; else goto l1287366;
l1287366: ;
pbh_upper_1287270 = _1287368;
goto l1287268;
l1287267: ;
union variant_220130 _1265919_9068;
_1265919_9068.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9070;
_1265920_9070.e0 = 1;
_1265920_9070.e1 = _1265919_9068;
pbh_upper_1287270 = _1265920_9070;
goto l1287268;
l1287268: ;
bh_upper_1287270 = pbh_upper_1287270;
unsigned int _1287271;
_1287271 = bh_lower_1287266.e0;
union variant_220130 _1287277;
_1287277 = bh_upper_1287270.e1;
bool _1287272;
_1287272 = _1287271 == 0;
union variant_220130 _1287280;
_1287280 = bh_lower_1287266.e1;
unsigned int _1287273;
_1287273 = bh_upper_1287270.e0;
bool _1287274;
_1287274 = _1287273 == 0;
bool _1287275;
_1287275 = _1287272 & _1287274;
if (_1287275) goto l1287276; else goto l1287357;
l1287357: ;
bool _1287358;
_1287358 = _1287271 == 1;
if (_1287358) goto l1287359; else goto l1287361;
l1287361: ;
bool _1287362;
_1287362 = _1287273 == 1;
if (_1287362) goto l1287363; else goto l1287365;
l1287365: ;
// bottom: float r4_1265918_9082;
// bottom: p_1287289 = r4_1265918_9082;
goto l1287287;
l1287363: ;
float c_1287364;
c_1287364 = _1287277.pf32;
p_1287289 = c_1287364;
goto l1287287;
l1287359: ;
float c_1287360;
c_1287360 = _1287280.pf32;
p_1287289 = c_1287360;
goto l1287287;
l1287276: ;
int y_1287278;
y_1287278 = _1287277.qs32;
int x_1287281;
x_1287281 = _1287280.qs32;
int _1287279;
_1287279 = y_1287278 * _1287191;
int _1287282;
_1287282 = _1287279 + x_1287281;
float* idx_1287283;
idx_1287283 = _1038848_1287140 + _1287282;
_1287286 = __ldg(idx_1287283);
p_1287286 = _1287286;
l1287284: ;
_1287286 = p_1287286;
p_1287289 = _1287286;
goto l1287287;
l1287287: ;
_1287289 = p_1287289;
if (_1287167) goto l1287290; else goto l1287354;
l1287354: ;
pbh_lower_1287293 = _1287356;
goto l1287291;
l1287290: ;
union variant_220130 _1265919_9083;
_1265919_9083.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9085;
_1265920_9085.e0 = 1;
_1265920_9085.e1 = _1265919_9083;
pbh_lower_1287293 = _1265920_9085;
goto l1287291;
l1287291: ;
bh_lower_1287293 = pbh_lower_1287293;
int _1287294;
_1287294 = 1 + gid_y_1287177;
bool _1287295;
_1287295 = _1287172 <= _1287294;
if (_1287295) goto l1287296; else goto l1287351;
l1287351: ;
union variant_220130 _1287352;
_1287352.qs32 = _1287294;
struct_BoundaryMode_220129 _1287353;
_1287353.e0 = 0;
_1287353.e1 = _1287352;
pbh_upper_1287299 = _1287353;
goto l1287297;
l1287296: ;
union variant_220130 _1265919_9093;
_1265919_9093.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9095;
_1265920_9095.e0 = 1;
_1265920_9095.e1 = _1265919_9093;
pbh_upper_1287299 = _1265920_9095;
goto l1287297;
l1287297: ;
bh_upper_1287299 = pbh_upper_1287299;
union variant_220130 _1287306;
_1287306 = bh_upper_1287299.e1;
union variant_220130 _1287309;
_1287309 = bh_lower_1287293.e1;
unsigned int _1287300;
_1287300 = bh_lower_1287293.e0;
bool _1287301;
_1287301 = _1287300 == 0;
unsigned int _1287302;
_1287302 = bh_upper_1287299.e0;
bool _1287303;
_1287303 = _1287302 == 0;
bool _1287304;
_1287304 = _1287301 & _1287303;
if (_1287304) goto l1287305; else goto l1287342;
l1287342: ;
bool _1287343;
_1287343 = _1287300 == 1;
if (_1287343) goto l1287344; else goto l1287346;
l1287346: ;
bool _1287347;
_1287347 = _1287302 == 1;
if (_1287347) goto l1287348; else goto l1287350;
l1287350: ;
// bottom: float r4_1265918_9107;
// bottom: p_1287318 = r4_1265918_9107;
goto l1287316;
l1287348: ;
float c_1287349;
c_1287349 = _1287306.pf32;
p_1287318 = c_1287349;
goto l1287316;
l1287344: ;
float c_1287345;
c_1287345 = _1287309.pf32;
p_1287318 = c_1287345;
goto l1287316;
l1287305: ;
int x_1287310;
x_1287310 = _1287309.qs32;
int y_1287307;
y_1287307 = _1287306.qs32;
int _1287308;
_1287308 = y_1287307 * _1287191;
int _1287311;
_1287311 = _1287308 + x_1287310;
float* idx_1287312;
idx_1287312 = _1038848_1287140 + _1287311;
_1287315 = __ldg(idx_1287312);
p_1287315 = _1287315;
l1287313: ;
_1287315 = p_1287315;
p_1287318 = _1287315;
goto l1287316;
l1287316: ;
_1287318 = p_1287318;
float _1287329;
_1287329 = _1287328;
float _1287336;
_1287336 = 2.500000e-01f * _1287289;
float _1287334;
_1287334 = 2.500000e-01f * _1287260;
float _1287323;
_1287323 = 2.000000e-01f * _1287202;
float _1287332;
_1287332 = 2.500000e-01f * _1287231;
float _1287338;
_1287338 = 2.500000e-01f * _1287318;
float _1287330;
_1287330 = 2.000000e-01f * _1287329;
float _1287333;
_1287333 = 0.000000e+00f + _1287332;
int _1287319;
_1287319 = _1038847_1287139.e3;
float _1287335;
_1287335 = _1287333 + _1287334;
float _1287337;
_1287337 = _1287335 + _1287336;
float _1287331;
_1287331 = _1287323 + _1287330;
float _1287339;
_1287339 = _1287337 + _1287338;
int _1287320;
_1287320 = gid_y_1287177 * _1287319;
float val_1287340;
val_1287340 = _1287331 + _1287339;
int _1287321;
_1287321 = _1287320 + gid_x_1287166;
float* idx_1287322;
idx_1287322 = _1038850_1287142 + _1287321;
*idx_1287322 = val_1287340;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1020925(float* _1020928_1272193, struct_Img_220118 _1020929_1272194, float* _1020930_1272195, float* _1020931_1272196, struct_Img_220118 _1020932_1272197, struct_Img_220118 _1020933_1272198) {
int _1272201;
int p_1272201;
int _1272204;
int p_1272204;
int _1272207;
int p_1272207;
int _1272210;
int p_1272210;
int _1272213;
int p_1272213;
int _1272216;
int p_1272216;
int _1272219;
int p_1272219;
struct_BoundaryMode_220129 bh_lower_1272226;
struct_BoundaryMode_220129 pbh_lower_1272226;
float _1272241;
float p_1272241;
float _1272244;
float p_1272244;
struct_BoundaryMode_220129 bh_lower_1272250;
struct_BoundaryMode_220129 pbh_lower_1272250;
float _1272262;
float p_1272262;
float _1272265;
float p_1272265;
struct_BoundaryMode_220129 bh_lower_1272269;
struct_BoundaryMode_220129 pbh_lower_1272269;
float _1272281;
float p_1272281;
float _1272284;
float p_1272284;
struct_BoundaryMode_220129 bh_lower_1272288;
struct_BoundaryMode_220129 pbh_lower_1272288;
float _1272300;
float p_1272300;
float _1272303;
float p_1272303;
struct_BoundaryMode_220129 bh_lower_1272309;
struct_BoundaryMode_220129 pbh_lower_1272309;
float _1272321;
float p_1272321;
float _1272324;
float p_1272324;
_1272201 = threadIdx_x();
p_1272201 = _1272201;
l1272199: ;
_1272201 = p_1272201;
_1272204 = blockDim_x();
p_1272204 = _1272204;
l1272202: ;
_1272204 = p_1272204;
_1272207 = blockIdx_x();
p_1272207 = _1272207;
l1272205: ;
_1272207 = p_1272207;
_1272210 = threadIdx_y();
p_1272210 = _1272210;
l1272208: ;
_1272210 = p_1272210;
_1272213 = blockDim_y();
p_1272213 = _1272213;
l1272211: ;
_1272213 = p_1272213;
_1272216 = blockIdx_y();
p_1272216 = _1272216;
l1272214: ;
_1272216 = p_1272216;
_1272219 = blockDim_y();
p_1272219 = _1272219;
l1272217: ;
_1272219 = p_1272219;
int _1272220;
_1272220 = _1272213 * _1272216;
int gid_y_1272221;
gid_y_1272221 = _1272210 + _1272220;
bool _1272222;
_1272222 = gid_y_1272221 < 0;
union variant_220130 _1272364;
_1272364.qs32 = gid_y_1272221;
struct_BoundaryMode_220129 _1272365;
_1272365.e0 = 0;
_1272365.e1 = _1272364;
if (_1272222) goto l1272223; else goto l1272386;
l1272386: ;
pbh_lower_1272226 = _1272365;
goto l1272224;
l1272223: ;
union variant_220130 _1265919_9120;
_1265919_9120.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9122;
_1265920_9122.e0 = 1;
_1265920_9122.e1 = _1265919_9120;
pbh_lower_1272226 = _1265920_9122;
goto l1272224;
l1272224: ;
bh_lower_1272226 = pbh_lower_1272226;
int _1272232;
_1272232 = _1020932_1272197.e3;
union variant_220130 _1272230;
_1272230 = bh_lower_1272226.e1;
unsigned int _1272227;
_1272227 = bh_lower_1272226.e0;
int _1272234;
_1272234 = _1272204 * _1272207;
bool _1272228;
_1272228 = _1272227 == 0;
int gid_x_1272235;
gid_x_1272235 = _1272201 + _1272234;
if (_1272228) goto l1272229; else goto l1272381;
l1272381: ;
bool _1272382;
_1272382 = _1272227 == 1;
if (_1272382) goto l1272383; else goto l1272385;
l1272385: ;
// bottom: float r4_1265918_9131;
// bottom: p_1272244 = r4_1265918_9131;
goto l1272242;
l1272383: ;
float c_1272384;
c_1272384 = _1272230.pf32;
p_1272244 = c_1272384;
goto l1272242;
l1272229: ;
int y_1272231;
y_1272231 = _1272230.qs32;
int _1272233;
_1272233 = y_1272231 * _1272232;
int _1272236;
_1272236 = _1272233 + gid_x_1272235;
int _1272237;
_1272237 = 128 + _1272236;
float* idx_1272238;
idx_1272238 = _1020931_1272196 + _1272237;
_1272241 = __ldg(idx_1272238);
p_1272241 = _1272241;
l1272239: ;
_1272241 = p_1272241;
p_1272244 = _1272241;
goto l1272242;
l1272242: ;
_1272244 = p_1272244;
int _1272245;
_1272245 = -1 + gid_y_1272221;
int _1272331;
_1272331 = _1020933_1272198.e3;
int _1272332;
_1272332 = gid_y_1272221 * _1272331;
bool _1272246;
_1272246 = _1272245 < 0;
int _1272333;
_1272333 = _1272332 + gid_x_1272235;
int _1272334;
_1272334 = 128 + _1272333;
float* idx_1272335;
idx_1272335 = _1020928_1272193 + _1272334;
float _1272336;
_1272336 = *idx_1272335;
if (_1272246) goto l1272247; else goto l1272378;
l1272378: ;
union variant_220130 _1272379;
_1272379.qs32 = _1272245;
struct_BoundaryMode_220129 _1272380;
_1272380.e0 = 0;
_1272380.e1 = _1272379;
pbh_lower_1272250 = _1272380;
goto l1272248;
l1272247: ;
union variant_220130 _1265919_9140;
_1265919_9140.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9142;
_1265920_9142.e0 = 1;
_1265920_9142.e1 = _1265919_9140;
pbh_lower_1272250 = _1265920_9142;
goto l1272248;
l1272248: ;
bh_lower_1272250 = pbh_lower_1272250;
union variant_220130 _1272254;
_1272254 = bh_lower_1272250.e1;
unsigned int _1272251;
_1272251 = bh_lower_1272250.e0;
bool _1272252;
_1272252 = _1272251 == 0;
if (_1272252) goto l1272253; else goto l1272372;
l1272372: ;
bool _1272373;
_1272373 = _1272251 == 1;
if (_1272373) goto l1272374; else goto l1272376;
l1272376: ;
// bottom: float r4_1265918_9150;
// bottom: p_1272265 = r4_1265918_9150;
goto l1272263;
l1272374: ;
float c_1272375;
c_1272375 = _1272254.pf32;
p_1272265 = c_1272375;
goto l1272263;
l1272253: ;
int y_1272255;
y_1272255 = _1272254.qs32;
int _1272256;
_1272256 = y_1272255 * _1272232;
int _1272257;
_1272257 = _1272256 + gid_x_1272235;
int _1272258;
_1272258 = 128 + _1272257;
float* idx_1272259;
idx_1272259 = _1020931_1272196 + _1272258;
_1272262 = __ldg(idx_1272259);
p_1272262 = _1272262;
l1272260: ;
_1272262 = p_1272262;
p_1272265 = _1272262;
goto l1272263;
l1272263: ;
_1272265 = p_1272265;
if (_1272222) goto l1272266; else goto l1272371;
l1272371: ;
pbh_lower_1272269 = _1272365;
goto l1272267;
l1272266: ;
union variant_220130 _1265919_9152;
_1265919_9152.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9154;
_1265920_9154.e0 = 1;
_1265920_9154.e1 = _1265919_9152;
pbh_lower_1272269 = _1265920_9154;
goto l1272267;
l1272267: ;
bh_lower_1272269 = pbh_lower_1272269;
union variant_220130 _1272273;
_1272273 = bh_lower_1272269.e1;
unsigned int _1272270;
_1272270 = bh_lower_1272269.e0;
bool _1272271;
_1272271 = _1272270 == 0;
if (_1272271) goto l1272272; else goto l1272366;
l1272366: ;
bool _1272367;
_1272367 = _1272270 == 1;
if (_1272367) goto l1272368; else goto l1272370;
l1272370: ;
// bottom: float r4_1265918_9162;
// bottom: p_1272284 = r4_1265918_9162;
goto l1272282;
l1272368: ;
float c_1272369;
c_1272369 = _1272273.pf32;
p_1272284 = c_1272369;
goto l1272282;
l1272272: ;
int y_1272274;
y_1272274 = _1272273.qs32;
int _1272275;
_1272275 = y_1272274 * _1272232;
int _1272276;
_1272276 = _1272275 + gid_x_1272235;
int _1272277;
_1272277 = 127 + _1272276;
float* idx_1272278;
idx_1272278 = _1020931_1272196 + _1272277;
_1272281 = __ldg(idx_1272278);
p_1272281 = _1272281;
l1272279: ;
_1272281 = p_1272281;
p_1272284 = _1272281;
goto l1272282;
l1272282: ;
_1272284 = p_1272284;
if (_1272222) goto l1272285; else goto l1272363;
l1272363: ;
pbh_lower_1272288 = _1272365;
goto l1272286;
l1272285: ;
union variant_220130 _1265919_9164;
_1265919_9164.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9166;
_1265920_9166.e0 = 1;
_1265920_9166.e1 = _1265919_9164;
pbh_lower_1272288 = _1265920_9166;
goto l1272286;
l1272286: ;
bh_lower_1272288 = pbh_lower_1272288;
union variant_220130 _1272292;
_1272292 = bh_lower_1272288.e1;
unsigned int _1272289;
_1272289 = bh_lower_1272288.e0;
bool _1272290;
_1272290 = _1272289 == 0;
if (_1272290) goto l1272291; else goto l1272358;
l1272358: ;
bool _1272359;
_1272359 = _1272289 == 1;
if (_1272359) goto l1272360; else goto l1272362;
l1272362: ;
// bottom: float r4_1265918_9174;
// bottom: p_1272303 = r4_1265918_9174;
goto l1272301;
l1272360: ;
float c_1272361;
c_1272361 = _1272292.pf32;
p_1272303 = c_1272361;
goto l1272301;
l1272291: ;
int y_1272293;
y_1272293 = _1272292.qs32;
int _1272294;
_1272294 = y_1272293 * _1272232;
int _1272295;
_1272295 = _1272294 + gid_x_1272235;
int _1272296;
_1272296 = 129 + _1272295;
float* idx_1272297;
idx_1272297 = _1020931_1272196 + _1272296;
_1272300 = __ldg(idx_1272297);
p_1272300 = _1272300;
l1272298: ;
_1272300 = p_1272300;
p_1272303 = _1272300;
goto l1272301;
l1272301: ;
_1272303 = p_1272303;
int _1272304;
_1272304 = 1 + gid_y_1272221;
bool _1272305;
_1272305 = _1272304 < 0;
if (_1272305) goto l1272306; else goto l1272355;
l1272355: ;
union variant_220130 _1272356;
_1272356.qs32 = _1272304;
struct_BoundaryMode_220129 _1272357;
_1272357.e0 = 0;
_1272357.e1 = _1272356;
pbh_lower_1272309 = _1272357;
goto l1272307;
l1272306: ;
union variant_220130 _1265919_9181;
_1265919_9181.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9183;
_1265920_9183.e0 = 1;
_1265920_9183.e1 = _1265919_9181;
pbh_lower_1272309 = _1265920_9183;
goto l1272307;
l1272307: ;
bh_lower_1272309 = pbh_lower_1272309;
unsigned int _1272310;
_1272310 = bh_lower_1272309.e0;
bool _1272311;
_1272311 = _1272310 == 0;
union variant_220130 _1272313;
_1272313 = bh_lower_1272309.e1;
if (_1272311) goto l1272312; else goto l1272350;
l1272350: ;
bool _1272351;
_1272351 = _1272310 == 1;
if (_1272351) goto l1272352; else goto l1272354;
l1272354: ;
// bottom: float r4_1265918_9191;
// bottom: p_1272324 = r4_1265918_9191;
goto l1272322;
l1272352: ;
float c_1272353;
c_1272353 = _1272313.pf32;
p_1272324 = c_1272353;
goto l1272322;
l1272312: ;
int y_1272314;
y_1272314 = _1272313.qs32;
int _1272315;
_1272315 = y_1272314 * _1272232;
int _1272316;
_1272316 = _1272315 + gid_x_1272235;
int _1272317;
_1272317 = 128 + _1272316;
float* idx_1272318;
idx_1272318 = _1020931_1272196 + _1272317;
_1272321 = __ldg(idx_1272318);
p_1272321 = _1272321;
l1272319: ;
_1272321 = p_1272321;
p_1272324 = _1272321;
goto l1272322;
l1272322: ;
_1272324 = p_1272324;
float _1272344;
_1272344 = 2.500000e-01f * _1272303;
float _1272340;
_1272340 = 2.500000e-01f * _1272265;
int _1272325;
_1272325 = _1020929_1272194.e3;
float _1272346;
_1272346 = 2.500000e-01f * _1272324;
int _1272326;
_1272326 = gid_y_1272221 * _1272325;
int _1272327;
_1272327 = _1272326 + gid_x_1272235;
float _1272342;
_1272342 = 2.500000e-01f * _1272284;
float _1272330;
_1272330 = 2.000000e-01f * _1272244;
float _1272337;
_1272337 = _1272336;
int _1272328;
_1272328 = 128 + _1272327;
float* idx_1272329;
idx_1272329 = _1020930_1272195 + _1272328;
float _1272341;
_1272341 = 0.000000e+00f + _1272340;
float _1272343;
_1272343 = _1272341 + _1272342;
float _1272338;
_1272338 = 2.000000e-01f * _1272337;
float _1272345;
_1272345 = _1272343 + _1272344;
float _1272339;
_1272339 = _1272330 + _1272338;
float _1272347;
_1272347 = _1272345 + _1272346;
float val_1272348;
val_1272348 = _1272339 + _1272347;
*idx_1272329 = val_1272348;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1031997(struct_Img_220118 _1032000_1269614, float* _1032001_1269615, float* _1032002_1269616, struct_Img_220118 _1032003_1269617, struct_Img_220118 _1032004_1269618, float* _1032005_1269619) {
int _1269622;
int p_1269622;
int _1269625;
int p_1269625;
int _1269628;
int p_1269628;
int _1269631;
int p_1269631;
int _1269634;
int p_1269634;
int _1269637;
int p_1269637;
int _1269640;
int p_1269640;
struct_BoundaryMode_220129 bh_upper_1269651;
struct_BoundaryMode_220129 pbh_upper_1269651;
float _1269666;
float p_1269666;
float _1269669;
float p_1269669;
struct_BoundaryMode_220129 bh_upper_1269673;
struct_BoundaryMode_220129 pbh_upper_1269673;
float _1269684;
float p_1269684;
float _1269687;
float p_1269687;
struct_BoundaryMode_220129 bh_upper_1269693;
struct_BoundaryMode_220129 pbh_upper_1269693;
float _1269703;
float p_1269703;
float _1269706;
float p_1269706;
struct_BoundaryMode_220129 bh_upper_1269712;
struct_BoundaryMode_220129 pbh_upper_1269712;
float _1269722;
float p_1269722;
float _1269725;
float p_1269725;
struct_BoundaryMode_220129 bh_upper_1269729;
struct_BoundaryMode_220129 pbh_upper_1269729;
float _1269741;
float p_1269741;
float _1269744;
float p_1269744;
_1269622 = threadIdx_x();
p_1269622 = _1269622;
l1269620: ;
_1269622 = p_1269622;
_1269625 = blockDim_x();
p_1269625 = _1269625;
l1269623: ;
_1269625 = p_1269625;
_1269628 = blockIdx_x();
p_1269628 = _1269628;
l1269626: ;
_1269628 = p_1269628;
_1269631 = threadIdx_y();
p_1269631 = _1269631;
l1269629: ;
_1269631 = p_1269631;
_1269634 = blockDim_y();
p_1269634 = _1269634;
l1269632: ;
_1269634 = p_1269634;
_1269637 = blockIdx_y();
p_1269637 = _1269637;
l1269635: ;
_1269637 = p_1269637;
_1269640 = blockDim_y();
p_1269640 = _1269640;
l1269638: ;
_1269640 = p_1269640;
int _1269642;
_1269642 = _1032004_1269618.e1;
int _1269643;
_1269643 = _1269642 - 128;
int _1269645;
_1269645 = _1269625 * _1269628;
int _1269641;
_1269641 = _1032003_1269617.e1;
int _1269644;
_1269644 = _1269643 + _1269622;
int gid_x_1269646;
gid_x_1269646 = _1269644 + _1269645;
bool _1269647;
_1269647 = _1269641 <= gid_x_1269646;
union variant_220130 _1269774;
_1269774.qs32 = gid_x_1269646;
struct_BoundaryMode_220129 _1269775;
_1269775.e0 = 0;
_1269775.e1 = _1269774;
if (_1269647) goto l1269648; else goto l1269804;
l1269804: ;
pbh_upper_1269651 = _1269775;
goto l1269649;
l1269648: ;
union variant_220130 _1265919_9208;
_1265919_9208.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9210;
_1265920_9210.e0 = 1;
_1265920_9210.e1 = _1265919_9208;
pbh_upper_1269651 = _1265920_9210;
goto l1269649;
l1269649: ;
bh_upper_1269651 = pbh_upper_1269651;
union variant_220130 _1269660;
_1269660 = bh_upper_1269651.e1;
int _1269658;
_1269658 = _1032003_1269617.e3;
int _1269655;
_1269655 = _1269634 * _1269637;
unsigned int _1269652;
_1269652 = bh_upper_1269651.e0;
int gid_y_1269656;
gid_y_1269656 = _1269631 + _1269655;
bool _1269653;
_1269653 = _1269652 == 0;
int _1269657;
_1269657 = 1 + gid_y_1269656;
int _1269659;
_1269659 = _1269657 * _1269658;
if (_1269653) goto l1269654; else goto l1269799;
l1269799: ;
bool _1269800;
_1269800 = _1269652 == 1;
if (_1269800) goto l1269801; else goto l1269803;
l1269803: ;
// bottom: float r4_1265918_9220;
// bottom: p_1269669 = r4_1265918_9220;
goto l1269667;
l1269801: ;
float c_1269802;
c_1269802 = _1269660.pf32;
p_1269669 = c_1269802;
goto l1269667;
l1269654: ;
int x_1269661;
x_1269661 = _1269660.qs32;
int _1269662;
_1269662 = _1269659 + x_1269661;
float* idx_1269663;
idx_1269663 = _1032002_1269616 + _1269662;
_1269666 = __ldg(idx_1269663);
p_1269666 = _1269666;
l1269664: ;
_1269666 = p_1269666;
p_1269669 = _1269666;
goto l1269667;
l1269667: ;
_1269669 = p_1269669;
int _1269750;
_1269750 = _1032000_1269614.e3;
int _1269751;
_1269751 = _1269657 * _1269750;
int _1269752;
_1269752 = _1269751 + gid_x_1269646;
float* idx_1269753;
idx_1269753 = _1032005_1269619 + _1269752;
float _1269754;
_1269754 = *idx_1269753;
if (_1269647) goto l1269670; else goto l1269798;
l1269798: ;
pbh_upper_1269673 = _1269775;
goto l1269671;
l1269670: ;
union variant_220130 _1265919_9222;
_1265919_9222.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9224;
_1265920_9224.e0 = 1;
_1265920_9224.e1 = _1265919_9222;
pbh_upper_1269673 = _1265920_9224;
goto l1269671;
l1269671: ;
bh_upper_1269673 = pbh_upper_1269673;
unsigned int _1269674;
_1269674 = bh_upper_1269673.e0;
union variant_220130 _1269678;
_1269678 = bh_upper_1269673.e1;
bool _1269675;
_1269675 = _1269674 == 0;
if (_1269675) goto l1269676; else goto l1269792;
l1269792: ;
bool _1269793;
_1269793 = _1269674 == 1;
if (_1269793) goto l1269794; else goto l1269796;
l1269796: ;
// bottom: float r4_1265918_9232;
// bottom: p_1269687 = r4_1265918_9232;
goto l1269685;
l1269794: ;
float c_1269795;
c_1269795 = _1269678.pf32;
p_1269687 = c_1269795;
goto l1269685;
l1269676: ;
int _1269677;
_1269677 = gid_y_1269656 * _1269658;
int x_1269679;
x_1269679 = _1269678.qs32;
int _1269680;
_1269680 = _1269677 + x_1269679;
float* idx_1269681;
idx_1269681 = _1032002_1269616 + _1269680;
_1269684 = __ldg(idx_1269681);
p_1269684 = _1269684;
l1269682: ;
_1269684 = p_1269684;
p_1269687 = _1269684;
goto l1269685;
l1269685: ;
_1269687 = p_1269687;
int _1269688;
_1269688 = -1 + gid_x_1269646;
bool _1269689;
_1269689 = _1269641 <= _1269688;
if (_1269689) goto l1269690; else goto l1269789;
l1269789: ;
union variant_220130 _1269790;
_1269790.qs32 = _1269688;
struct_BoundaryMode_220129 _1269791;
_1269791.e0 = 0;
_1269791.e1 = _1269790;
pbh_upper_1269693 = _1269791;
goto l1269691;
l1269690: ;
union variant_220130 _1265919_9237;
_1265919_9237.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9239;
_1265920_9239.e0 = 1;
_1265920_9239.e1 = _1265919_9237;
pbh_upper_1269693 = _1265920_9239;
goto l1269691;
l1269691: ;
bh_upper_1269693 = pbh_upper_1269693;
union variant_220130 _1269697;
_1269697 = bh_upper_1269693.e1;
unsigned int _1269694;
_1269694 = bh_upper_1269693.e0;
bool _1269695;
_1269695 = _1269694 == 0;
if (_1269695) goto l1269696; else goto l1269784;
l1269784: ;
bool _1269785;
_1269785 = _1269694 == 1;
if (_1269785) goto l1269786; else goto l1269788;
l1269788: ;
// bottom: float r4_1265918_9247;
// bottom: p_1269706 = r4_1265918_9247;
goto l1269704;
l1269786: ;
float c_1269787;
c_1269787 = _1269697.pf32;
p_1269706 = c_1269787;
goto l1269704;
l1269696: ;
int x_1269698;
x_1269698 = _1269697.qs32;
int _1269699;
_1269699 = _1269659 + x_1269698;
float* idx_1269700;
idx_1269700 = _1032002_1269616 + _1269699;
_1269703 = __ldg(idx_1269700);
p_1269703 = _1269703;
l1269701: ;
_1269703 = p_1269703;
p_1269706 = _1269703;
goto l1269704;
l1269704: ;
_1269706 = p_1269706;
int _1269707;
_1269707 = 1 + gid_x_1269646;
bool _1269708;
_1269708 = _1269641 <= _1269707;
if (_1269708) goto l1269709; else goto l1269781;
l1269781: ;
union variant_220130 _1269782;
_1269782.qs32 = _1269707;
struct_BoundaryMode_220129 _1269783;
_1269783.e0 = 0;
_1269783.e1 = _1269782;
pbh_upper_1269712 = _1269783;
goto l1269710;
l1269709: ;
union variant_220130 _1265919_9252;
_1265919_9252.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9254;
_1265920_9254.e0 = 1;
_1265920_9254.e1 = _1265919_9252;
pbh_upper_1269712 = _1265920_9254;
goto l1269710;
l1269710: ;
bh_upper_1269712 = pbh_upper_1269712;
union variant_220130 _1269716;
_1269716 = bh_upper_1269712.e1;
unsigned int _1269713;
_1269713 = bh_upper_1269712.e0;
bool _1269714;
_1269714 = _1269713 == 0;
if (_1269714) goto l1269715; else goto l1269776;
l1269776: ;
bool _1269777;
_1269777 = _1269713 == 1;
if (_1269777) goto l1269778; else goto l1269780;
l1269780: ;
// bottom: float r4_1265918_9262;
// bottom: p_1269725 = r4_1265918_9262;
goto l1269723;
l1269778: ;
float c_1269779;
c_1269779 = _1269716.pf32;
p_1269725 = c_1269779;
goto l1269723;
l1269715: ;
int x_1269717;
x_1269717 = _1269716.qs32;
int _1269718;
_1269718 = _1269659 + x_1269717;
float* idx_1269719;
idx_1269719 = _1032002_1269616 + _1269718;
_1269722 = __ldg(idx_1269719);
p_1269722 = _1269722;
l1269720: ;
_1269722 = p_1269722;
p_1269725 = _1269722;
goto l1269723;
l1269723: ;
_1269725 = p_1269725;
if (_1269647) goto l1269726; else goto l1269773;
l1269773: ;
pbh_upper_1269729 = _1269775;
goto l1269727;
l1269726: ;
union variant_220130 _1265919_9263;
_1265919_9263.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9265;
_1265920_9265.e0 = 1;
_1265920_9265.e1 = _1265919_9263;
pbh_upper_1269729 = _1265920_9265;
goto l1269727;
l1269727: ;
bh_upper_1269729 = pbh_upper_1269729;
unsigned int _1269730;
_1269730 = bh_upper_1269729.e0;
bool _1269731;
_1269731 = _1269730 == 0;
union variant_220130 _1269735;
_1269735 = bh_upper_1269729.e1;
if (_1269731) goto l1269732; else goto l1269768;
l1269768: ;
bool _1269769;
_1269769 = _1269730 == 1;
if (_1269769) goto l1269770; else goto l1269772;
l1269772: ;
// bottom: float r4_1265918_9273;
// bottom: p_1269744 = r4_1265918_9273;
goto l1269742;
l1269770: ;
float c_1269771;
c_1269771 = _1269735.pf32;
p_1269744 = c_1269771;
goto l1269742;
l1269732: ;
int x_1269736;
x_1269736 = _1269735.qs32;
int _1269733;
_1269733 = 2 + gid_y_1269656;
int _1269734;
_1269734 = _1269733 * _1269658;
int _1269737;
_1269737 = _1269734 + x_1269736;
float* idx_1269738;
idx_1269738 = _1032002_1269616 + _1269737;
_1269741 = __ldg(idx_1269738);
p_1269741 = _1269741;
l1269739: ;
_1269741 = p_1269741;
p_1269744 = _1269741;
goto l1269742;
l1269742: ;
_1269744 = p_1269744;
float _1269760;
_1269760 = 2.500000e-01f * _1269706;
float _1269758;
_1269758 = 2.500000e-01f * _1269687;
float _1269755;
_1269755 = _1269754;
int _1269745;
_1269745 = _1032004_1269618.e3;
float _1269762;
_1269762 = 2.500000e-01f * _1269725;
float _1269764;
_1269764 = 2.500000e-01f * _1269744;
float _1269749;
_1269749 = 2.000000e-01f * _1269669;
float _1269759;
_1269759 = 0.000000e+00f + _1269758;
float _1269756;
_1269756 = 2.000000e-01f * _1269755;
int _1269746;
_1269746 = _1269657 * _1269745;
float _1269757;
_1269757 = _1269749 + _1269756;
float _1269761;
_1269761 = _1269759 + _1269760;
int _1269747;
_1269747 = _1269746 + gid_x_1269646;
float _1269763;
_1269763 = _1269761 + _1269762;
float* idx_1269748;
idx_1269748 = _1032001_1269615 + _1269747;
float _1269765;
_1269765 = _1269763 + _1269764;
float val_1269766;
val_1269766 = _1269757 + _1269765;
*idx_1269748 = val_1269766;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1001857(struct_Img_220118 _1001860_1267182, float* _1001861_1267183, struct_Img_220118 _1001862_1267184, float* _1001863_1267185, float* _1001864_1267186, struct_Img_220118 _1001865_1267187) {
int _1267190;
int p_1267190;
int _1267193;
int p_1267193;
int _1267196;
int p_1267196;
int _1267199;
int p_1267199;
int _1267202;
int p_1267202;
int _1267205;
int p_1267205;
int _1267208;
int p_1267208;
float _1267221;
float p_1267221;
float _1267235;
float p_1267235;
float _1267240;
float p_1267240;
float _1267245;
float p_1267245;
float _1267253;
float p_1267253;
_1267190 = threadIdx_x();
p_1267190 = _1267190;
l1267188: ;
_1267190 = p_1267190;
_1267193 = blockDim_x();
p_1267193 = _1267193;
l1267191: ;
_1267193 = p_1267193;
_1267196 = blockIdx_x();
p_1267196 = _1267196;
l1267194: ;
_1267196 = p_1267196;
_1267199 = threadIdx_y();
p_1267199 = _1267199;
l1267197: ;
_1267199 = p_1267199;
_1267202 = blockDim_y();
p_1267202 = _1267202;
l1267200: ;
_1267202 = p_1267202;
_1267205 = blockIdx_y();
p_1267205 = _1267205;
l1267203: ;
_1267205 = p_1267205;
_1267208 = blockDim_y();
p_1267208 = _1267208;
l1267206: ;
_1267208 = p_1267208;
int _1267214;
_1267214 = _1267193 * _1267196;
int _1267209;
_1267209 = _1267202 * _1267205;
int _1267212;
_1267212 = _1001860_1267182.e3;
int gid_x_1267215;
gid_x_1267215 = _1267190 + _1267214;
int gid_y_1267210;
gid_y_1267210 = _1267199 + _1267209;
int _1267211;
_1267211 = 1 + gid_y_1267210;
int _1267213;
_1267213 = _1267211 * _1267212;
int _1267216;
_1267216 = _1267213 + gid_x_1267215;
int _1267217;
_1267217 = 128 + _1267216;
float* idx_1267218;
idx_1267218 = _1001861_1267183 + _1267217;
_1267221 = __ldg(idx_1267218);
p_1267221 = _1267221;
l1267219: ;
_1267221 = p_1267221;
int _1267229;
_1267229 = gid_y_1267210 * _1267212;
int _1267222;
_1267222 = _1001862_1267184.e3;
int _1267223;
_1267223 = _1267211 * _1267222;
int _1267230;
_1267230 = _1267229 + gid_x_1267215;
int _1267224;
_1267224 = _1267223 + gid_x_1267215;
int _1267231;
_1267231 = 128 + _1267230;
int _1267225;
_1267225 = 128 + _1267224;
float* idx_1267232;
idx_1267232 = _1001861_1267183 + _1267231;
float* idx_1267226;
idx_1267226 = _1001864_1267186 + _1267225;
float _1267227;
_1267227 = *idx_1267226;
_1267235 = __ldg(idx_1267232);
p_1267235 = _1267235;
l1267233: ;
_1267235 = p_1267235;
int _1267236;
_1267236 = 127 + _1267216;
float* idx_1267237;
idx_1267237 = _1001861_1267183 + _1267236;
_1267240 = __ldg(idx_1267237);
p_1267240 = _1267240;
l1267238: ;
_1267240 = p_1267240;
int _1267241;
_1267241 = 129 + _1267216;
float* idx_1267242;
idx_1267242 = _1001861_1267183 + _1267241;
_1267245 = __ldg(idx_1267242);
p_1267245 = _1267245;
l1267243: ;
_1267245 = p_1267245;
int _1267246;
_1267246 = 2 + gid_y_1267210;
int _1267247;
_1267247 = _1267246 * _1267212;
int _1267248;
_1267248 = _1267247 + gid_x_1267215;
int _1267249;
_1267249 = 128 + _1267248;
float* idx_1267250;
idx_1267250 = _1001861_1267183 + _1267249;
_1267253 = __ldg(idx_1267250);
p_1267253 = _1267253;
l1267251: ;
_1267253 = p_1267253;
float _1267265;
_1267265 = 2.500000e-01f * _1267240;
float _1267263;
_1267263 = 2.500000e-01f * _1267235;
float _1267259;
_1267259 = 2.000000e-01f * _1267221;
float _1267264;
_1267264 = 0.000000e+00f + _1267263;
float _1267267;
_1267267 = 2.500000e-01f * _1267245;
int _1267254;
_1267254 = _1001865_1267187.e3;
float _1267260;
_1267260 = _1267227;
float _1267269;
_1267269 = 2.500000e-01f * _1267253;
int _1267255;
_1267255 = _1267211 * _1267254;
float _1267261;
_1267261 = 2.000000e-01f * _1267260;
float _1267262;
_1267262 = _1267259 + _1267261;
float _1267266;
_1267266 = _1267264 + _1267265;
float _1267268;
_1267268 = _1267266 + _1267267;
float _1267270;
_1267270 = _1267268 + _1267269;
int _1267256;
_1267256 = _1267255 + gid_x_1267215;
float val_1267271;
val_1267271 = _1267262 + _1267270;
int _1267257;
_1267257 = 128 + _1267256;
float* idx_1267258;
idx_1267258 = _1001863_1267185 + _1267257;
*idx_1267258 = val_1267271;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1037841(struct_Img_220118 _1037844_1266911, struct_Img_220118 _1037845_1266912, float* _1037846_1266913, struct_Img_220118 _1037847_1266914, float* _1037848_1266915, float* _1037849_1266916) {
int _1266919;
int p_1266919;
int _1266922;
int p_1266922;
int _1266925;
int p_1266925;
int _1266928;
int p_1266928;
int _1266931;
int p_1266931;
int _1266934;
int p_1266934;
int _1266937;
int p_1266937;
struct_BoundaryMode_220129 bh_lower_1266944;
struct_BoundaryMode_220129 pbh_lower_1266944;
struct_BoundaryMode_220129 bh_lower_1266951;
struct_BoundaryMode_220129 pbh_lower_1266951;
float _1266968;
float p_1266968;
float _1266971;
float p_1266971;
struct_BoundaryMode_220129 bh_lower_1266975;
struct_BoundaryMode_220129 pbh_lower_1266975;
struct_BoundaryMode_220129 bh_lower_1266981;
struct_BoundaryMode_220129 pbh_lower_1266981;
float _1266997;
float p_1266997;
float _1267000;
float p_1267000;
struct_BoundaryMode_220129 bh_lower_1267006;
struct_BoundaryMode_220129 pbh_lower_1267006;
struct_BoundaryMode_220129 bh_lower_1267010;
struct_BoundaryMode_220129 pbh_lower_1267010;
float _1267026;
float p_1267026;
float _1267029;
float p_1267029;
struct_BoundaryMode_220129 bh_lower_1267035;
struct_BoundaryMode_220129 pbh_lower_1267035;
struct_BoundaryMode_220129 bh_lower_1267039;
struct_BoundaryMode_220129 pbh_lower_1267039;
float _1267055;
float p_1267055;
float _1267058;
float p_1267058;
struct_BoundaryMode_220129 bh_lower_1267062;
struct_BoundaryMode_220129 pbh_lower_1267062;
struct_BoundaryMode_220129 bh_lower_1267068;
struct_BoundaryMode_220129 pbh_lower_1267068;
float _1267084;
float p_1267084;
float _1267087;
float p_1267087;
_1266919 = threadIdx_x();
p_1266919 = _1266919;
l1266917: ;
_1266919 = p_1266919;
_1266922 = blockDim_x();
p_1266922 = _1266922;
l1266920: ;
_1266922 = p_1266922;
_1266925 = blockIdx_x();
p_1266925 = _1266925;
l1266923: ;
_1266925 = p_1266925;
_1266928 = threadIdx_y();
p_1266928 = _1266928;
l1266926: ;
_1266928 = p_1266928;
_1266931 = blockDim_y();
p_1266931 = _1266931;
l1266929: ;
_1266931 = p_1266931;
_1266934 = blockIdx_y();
p_1266934 = _1266934;
l1266932: ;
_1266934 = p_1266934;
_1266937 = blockDim_y();
p_1266937 = _1266937;
l1266935: ;
_1266937 = p_1266937;
int _1266938;
_1266938 = _1266922 * _1266925;
int gid_x_1266939;
gid_x_1266939 = _1266919 + _1266938;
bool _1266940;
_1266940 = gid_x_1266939 < 0;
union variant_220130 _1267124;
_1267124.qs32 = gid_x_1266939;
struct_BoundaryMode_220129 _1267125;
_1267125.e0 = 0;
_1267125.e1 = _1267124;
if (_1266940) goto l1266941; else goto l1267178;
l1267178: ;
pbh_lower_1266944 = _1267125;
goto l1266942;
l1266941: ;
union variant_220130 _1265919_9306;
_1265919_9306.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9308;
_1265920_9308.e0 = 1;
_1265920_9308.e1 = _1265919_9306;
pbh_lower_1266944 = _1265920_9308;
goto l1266942;
l1266942: ;
bh_lower_1266944 = pbh_lower_1266944;
int _1266945;
_1266945 = _1266931 * _1266934;
int gid_y_1266946;
gid_y_1266946 = _1266928 + _1266945;
bool _1266947;
_1266947 = gid_y_1266946 < 0;
union variant_220130 _1267136;
_1267136.qs32 = gid_y_1266946;
struct_BoundaryMode_220129 _1267137;
_1267137.e0 = 0;
_1267137.e1 = _1267136;
if (_1266947) goto l1266948; else goto l1267177;
l1267177: ;
pbh_lower_1266951 = _1267137;
goto l1266949;
l1266948: ;
union variant_220130 _1265919_9316;
_1265919_9316.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9318;
_1265920_9318.e0 = 1;
_1265920_9318.e1 = _1265919_9316;
pbh_lower_1266951 = _1265920_9318;
goto l1266949;
l1266949: ;
bh_lower_1266951 = pbh_lower_1266951;
unsigned int _1266952;
_1266952 = bh_lower_1266944.e0;
bool _1266953;
_1266953 = _1266952 == 0;
int _1266960;
_1266960 = _1037844_1266911.e3;
union variant_220130 _1266958;
_1266958 = bh_lower_1266951.e1;
unsigned int _1266954;
_1266954 = bh_lower_1266951.e0;
union variant_220130 _1266962;
_1266962 = bh_lower_1266944.e1;
bool _1266955;
_1266955 = _1266954 == 0;
bool _1266956;
_1266956 = _1266953 & _1266955;
if (_1266956) goto l1266957; else goto l1267168;
l1267168: ;
bool _1267169;
_1267169 = _1266952 == 1;
if (_1267169) goto l1267170; else goto l1267172;
l1267172: ;
bool _1267173;
_1267173 = _1266954 == 1;
if (_1267173) goto l1267174; else goto l1267176;
l1267176: ;
// bottom: float r4_1265918_9331;
// bottom: p_1266971 = r4_1265918_9331;
goto l1266969;
l1267174: ;
float c_1267175;
c_1267175 = _1266958.pf32;
p_1266971 = c_1267175;
goto l1266969;
l1267170: ;
float c_1267171;
c_1267171 = _1266962.pf32;
p_1266971 = c_1267171;
goto l1266969;
l1266957: ;
int y_1266959;
y_1266959 = _1266958.qs32;
int x_1266963;
x_1266963 = _1266962.qs32;
int _1266961;
_1266961 = y_1266959 * _1266960;
int _1266964;
_1266964 = _1266961 + x_1266963;
float* idx_1266965;
idx_1266965 = _1037846_1266913 + _1266964;
_1266968 = __ldg(idx_1266965);
p_1266968 = _1266968;
l1266966: ;
_1266968 = p_1266968;
p_1266971 = _1266968;
goto l1266969;
l1266969: ;
_1266971 = p_1266971;
int _1267093;
_1267093 = _1037847_1266914.e3;
int _1267094;
_1267094 = gid_y_1266946 * _1267093;
int _1267095;
_1267095 = _1267094 + gid_x_1266939;
float* idx_1267096;
idx_1267096 = _1037849_1266916 + _1267095;
float _1267097;
_1267097 = *idx_1267096;
if (_1266940) goto l1266972; else goto l1267167;
l1267167: ;
pbh_lower_1266975 = _1267125;
goto l1266973;
l1266972: ;
union variant_220130 _1265919_9333;
_1265919_9333.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9335;
_1265920_9335.e0 = 1;
_1265920_9335.e1 = _1265919_9333;
pbh_lower_1266975 = _1265920_9335;
goto l1266973;
l1266973: ;
bh_lower_1266975 = pbh_lower_1266975;
int _1266976;
_1266976 = -1 + gid_y_1266946;
bool _1266977;
_1266977 = _1266976 < 0;
if (_1266977) goto l1266978; else goto l1267163;
l1267163: ;
union variant_220130 _1267164;
_1267164.qs32 = _1266976;
struct_BoundaryMode_220129 _1267165;
_1267165.e0 = 0;
_1267165.e1 = _1267164;
pbh_lower_1266981 = _1267165;
goto l1266979;
l1266978: ;
union variant_220130 _1265919_9344;
_1265919_9344.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9346;
_1265920_9346.e0 = 1;
_1265920_9346.e1 = _1265919_9344;
pbh_lower_1266981 = _1265920_9346;
goto l1266979;
l1266979: ;
bh_lower_1266981 = pbh_lower_1266981;
union variant_220130 _1266988;
_1266988 = bh_lower_1266981.e1;
union variant_220130 _1266991;
_1266991 = bh_lower_1266975.e1;
unsigned int _1266982;
_1266982 = bh_lower_1266975.e0;
unsigned int _1266984;
_1266984 = bh_lower_1266981.e0;
bool _1266985;
_1266985 = _1266984 == 0;
bool _1266983;
_1266983 = _1266982 == 0;
bool _1266986;
_1266986 = _1266983 & _1266985;
if (_1266986) goto l1266987; else goto l1267154;
l1267154: ;
bool _1267155;
_1267155 = _1266982 == 1;
if (_1267155) goto l1267156; else goto l1267158;
l1267158: ;
bool _1267159;
_1267159 = _1266984 == 1;
if (_1267159) goto l1267160; else goto l1267162;
l1267162: ;
// bottom: float r4_1265918_9358;
// bottom: p_1267000 = r4_1265918_9358;
goto l1266998;
l1267160: ;
float c_1267161;
c_1267161 = _1266988.pf32;
p_1267000 = c_1267161;
goto l1266998;
l1267156: ;
float c_1267157;
c_1267157 = _1266991.pf32;
p_1267000 = c_1267157;
goto l1266998;
l1266987: ;
int x_1266992;
x_1266992 = _1266991.qs32;
int y_1266989;
y_1266989 = _1266988.qs32;
int _1266990;
_1266990 = y_1266989 * _1266960;
int _1266993;
_1266993 = _1266990 + x_1266992;
float* idx_1266994;
idx_1266994 = _1037846_1266913 + _1266993;
_1266997 = __ldg(idx_1266994);
p_1266997 = _1266997;
l1266995: ;
_1266997 = p_1266997;
p_1267000 = _1266997;
goto l1266998;
l1266998: ;
_1267000 = p_1267000;
int _1267001;
_1267001 = -1 + gid_x_1266939;
bool _1267002;
_1267002 = _1267001 < 0;
if (_1267002) goto l1267003; else goto l1267151;
l1267151: ;
union variant_220130 _1267152;
_1267152.qs32 = _1267001;
struct_BoundaryMode_220129 _1267153;
_1267153.e0 = 0;
_1267153.e1 = _1267152;
pbh_lower_1267006 = _1267153;
goto l1267004;
l1267003: ;
union variant_220130 _1265919_9364;
_1265919_9364.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9366;
_1265920_9366.e0 = 1;
_1265920_9366.e1 = _1265919_9364;
pbh_lower_1267006 = _1265920_9366;
goto l1267004;
l1267004: ;
bh_lower_1267006 = pbh_lower_1267006;
if (_1266947) goto l1267007; else goto l1267150;
l1267150: ;
pbh_lower_1267010 = _1267137;
goto l1267008;
l1267007: ;
union variant_220130 _1265919_9370;
_1265919_9370.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9372;
_1265920_9372.e0 = 1;
_1265920_9372.e1 = _1265919_9370;
pbh_lower_1267010 = _1265920_9372;
goto l1267008;
l1267008: ;
bh_lower_1267010 = pbh_lower_1267010;
union variant_220130 _1267020;
_1267020 = bh_lower_1267006.e1;
unsigned int _1267011;
_1267011 = bh_lower_1267006.e0;
union variant_220130 _1267017;
_1267017 = bh_lower_1267010.e1;
unsigned int _1267013;
_1267013 = bh_lower_1267010.e0;
bool _1267012;
_1267012 = _1267011 == 0;
bool _1267014;
_1267014 = _1267013 == 0;
bool _1267015;
_1267015 = _1267012 & _1267014;
if (_1267015) goto l1267016; else goto l1267141;
l1267141: ;
bool _1267142;
_1267142 = _1267011 == 1;
if (_1267142) goto l1267143; else goto l1267145;
l1267145: ;
bool _1267146;
_1267146 = _1267013 == 1;
if (_1267146) goto l1267147; else goto l1267149;
l1267149: ;
// bottom: float r4_1265918_9384;
// bottom: p_1267029 = r4_1265918_9384;
goto l1267027;
l1267147: ;
float c_1267148;
c_1267148 = _1267017.pf32;
p_1267029 = c_1267148;
goto l1267027;
l1267143: ;
float c_1267144;
c_1267144 = _1267020.pf32;
p_1267029 = c_1267144;
goto l1267027;
l1267016: ;
int x_1267021;
x_1267021 = _1267020.qs32;
int y_1267018;
y_1267018 = _1267017.qs32;
int _1267019;
_1267019 = y_1267018 * _1266960;
int _1267022;
_1267022 = _1267019 + x_1267021;
float* idx_1267023;
idx_1267023 = _1037846_1266913 + _1267022;
_1267026 = __ldg(idx_1267023);
p_1267026 = _1267026;
l1267024: ;
_1267026 = p_1267026;
p_1267029 = _1267026;
goto l1267027;
l1267027: ;
_1267029 = p_1267029;
int _1267030;
_1267030 = 1 + gid_x_1266939;
bool _1267031;
_1267031 = _1267030 < 0;
if (_1267031) goto l1267032; else goto l1267138;
l1267138: ;
union variant_220130 _1267139;
_1267139.qs32 = _1267030;
struct_BoundaryMode_220129 _1267140;
_1267140.e0 = 0;
_1267140.e1 = _1267139;
pbh_lower_1267035 = _1267140;
goto l1267033;
l1267032: ;
union variant_220130 _1265919_9390;
_1265919_9390.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9392;
_1265920_9392.e0 = 1;
_1265920_9392.e1 = _1265919_9390;
pbh_lower_1267035 = _1265920_9392;
goto l1267033;
l1267033: ;
bh_lower_1267035 = pbh_lower_1267035;
if (_1266947) goto l1267036; else goto l1267135;
l1267135: ;
pbh_lower_1267039 = _1267137;
goto l1267037;
l1267036: ;
union variant_220130 _1265919_9396;
_1265919_9396.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9398;
_1265920_9398.e0 = 1;
_1265920_9398.e1 = _1265919_9396;
pbh_lower_1267039 = _1265920_9398;
goto l1267037;
l1267037: ;
bh_lower_1267039 = pbh_lower_1267039;
unsigned int _1267042;
_1267042 = bh_lower_1267039.e0;
bool _1267043;
_1267043 = _1267042 == 0;
union variant_220130 _1267049;
_1267049 = bh_lower_1267035.e1;
unsigned int _1267040;
_1267040 = bh_lower_1267035.e0;
union variant_220130 _1267046;
_1267046 = bh_lower_1267039.e1;
bool _1267041;
_1267041 = _1267040 == 0;
bool _1267044;
_1267044 = _1267041 & _1267043;
if (_1267044) goto l1267045; else goto l1267126;
l1267126: ;
bool _1267127;
_1267127 = _1267040 == 1;
if (_1267127) goto l1267128; else goto l1267130;
l1267130: ;
bool _1267131;
_1267131 = _1267042 == 1;
if (_1267131) goto l1267132; else goto l1267134;
l1267134: ;
// bottom: float r4_1265918_9410;
// bottom: p_1267058 = r4_1265918_9410;
goto l1267056;
l1267132: ;
float c_1267133;
c_1267133 = _1267046.pf32;
p_1267058 = c_1267133;
goto l1267056;
l1267128: ;
float c_1267129;
c_1267129 = _1267049.pf32;
p_1267058 = c_1267129;
goto l1267056;
l1267045: ;
int x_1267050;
x_1267050 = _1267049.qs32;
int y_1267047;
y_1267047 = _1267046.qs32;
int _1267048;
_1267048 = y_1267047 * _1266960;
int _1267051;
_1267051 = _1267048 + x_1267050;
float* idx_1267052;
idx_1267052 = _1037846_1266913 + _1267051;
_1267055 = __ldg(idx_1267052);
p_1267055 = _1267055;
l1267053: ;
_1267055 = p_1267055;
p_1267058 = _1267055;
goto l1267056;
l1267056: ;
_1267058 = p_1267058;
if (_1266940) goto l1267059; else goto l1267123;
l1267123: ;
pbh_lower_1267062 = _1267125;
goto l1267060;
l1267059: ;
union variant_220130 _1265919_9411;
_1265919_9411.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9413;
_1265920_9413.e0 = 1;
_1265920_9413.e1 = _1265919_9411;
pbh_lower_1267062 = _1265920_9413;
goto l1267060;
l1267060: ;
bh_lower_1267062 = pbh_lower_1267062;
int _1267063;
_1267063 = 1 + gid_y_1266946;
bool _1267064;
_1267064 = _1267063 < 0;
if (_1267064) goto l1267065; else goto l1267120;
l1267120: ;
union variant_220130 _1267121;
_1267121.qs32 = _1267063;
struct_BoundaryMode_220129 _1267122;
_1267122.e0 = 0;
_1267122.e1 = _1267121;
pbh_lower_1267068 = _1267122;
goto l1267066;
l1267065: ;
union variant_220130 _1265919_9422;
_1265919_9422.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9424;
_1265920_9424.e0 = 1;
_1265920_9424.e1 = _1265919_9422;
pbh_lower_1267068 = _1265920_9424;
goto l1267066;
l1267066: ;
bh_lower_1267068 = pbh_lower_1267068;
union variant_220130 _1267078;
_1267078 = bh_lower_1267062.e1;
union variant_220130 _1267075;
_1267075 = bh_lower_1267068.e1;
unsigned int _1267071;
_1267071 = bh_lower_1267068.e0;
unsigned int _1267069;
_1267069 = bh_lower_1267062.e0;
bool _1267072;
_1267072 = _1267071 == 0;
bool _1267070;
_1267070 = _1267069 == 0;
bool _1267073;
_1267073 = _1267070 & _1267072;
if (_1267073) goto l1267074; else goto l1267111;
l1267111: ;
bool _1267112;
_1267112 = _1267069 == 1;
if (_1267112) goto l1267113; else goto l1267115;
l1267115: ;
bool _1267116;
_1267116 = _1267071 == 1;
if (_1267116) goto l1267117; else goto l1267119;
l1267119: ;
// bottom: float r4_1265918_9436;
// bottom: p_1267087 = r4_1265918_9436;
goto l1267085;
l1267117: ;
float c_1267118;
c_1267118 = _1267075.pf32;
p_1267087 = c_1267118;
goto l1267085;
l1267113: ;
float c_1267114;
c_1267114 = _1267078.pf32;
p_1267087 = c_1267114;
goto l1267085;
l1267074: ;
int x_1267079;
x_1267079 = _1267078.qs32;
int y_1267076;
y_1267076 = _1267075.qs32;
int _1267077;
_1267077 = y_1267076 * _1266960;
int _1267080;
_1267080 = _1267077 + x_1267079;
float* idx_1267081;
idx_1267081 = _1037846_1266913 + _1267080;
_1267084 = __ldg(idx_1267081);
p_1267084 = _1267084;
l1267082: ;
_1267084 = p_1267084;
p_1267087 = _1267084;
goto l1267085;
l1267085: ;
_1267087 = p_1267087;
float _1267105;
_1267105 = 2.500000e-01f * _1267058;
float _1267092;
_1267092 = 2.000000e-01f * _1266971;
float _1267103;
_1267103 = 2.500000e-01f * _1267029;
float _1267098;
_1267098 = _1267097;
float _1267107;
_1267107 = 2.500000e-01f * _1267087;
float _1267101;
_1267101 = 2.500000e-01f * _1267000;
float _1267102;
_1267102 = 0.000000e+00f + _1267101;
int _1267088;
_1267088 = _1037845_1266912.e3;
int _1267089;
_1267089 = gid_y_1266946 * _1267088;
float _1267104;
_1267104 = _1267102 + _1267103;
float _1267099;
_1267099 = 2.000000e-01f * _1267098;
int _1267090;
_1267090 = _1267089 + gid_x_1266939;
float _1267106;
_1267106 = _1267104 + _1267105;
float _1267100;
_1267100 = _1267092 + _1267099;
float* idx_1267091;
idx_1267091 = _1037848_1266915 + _1267090;
float _1267108;
_1267108 = _1267106 + _1267107;
float val_1267109;
val_1267109 = _1267100 + _1267108;
*idx_1267091 = val_1267109;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1030622(struct_Img_220118 _1030625_1267276, float* _1030626_1267277, float* _1030627_1267278, struct_Img_220118 _1030628_1267279, struct_Img_220118 _1030629_1267280, float* _1030630_1267281) {
int _1267284;
int p_1267284;
int _1267287;
int p_1267287;
int _1267290;
int p_1267290;
int _1267293;
int p_1267293;
int _1267296;
int p_1267296;
int _1267299;
int p_1267299;
int _1267302;
int p_1267302;
float _1267315;
float p_1267315;
float _1267329;
float p_1267329;
float _1267334;
float p_1267334;
float _1267339;
float p_1267339;
float _1267347;
float p_1267347;
_1267284 = threadIdx_x();
p_1267284 = _1267284;
l1267282: ;
_1267284 = p_1267284;
_1267287 = blockDim_x();
p_1267287 = _1267287;
l1267285: ;
_1267287 = p_1267287;
_1267290 = blockIdx_x();
p_1267290 = _1267290;
l1267288: ;
_1267290 = p_1267290;
_1267293 = threadIdx_y();
p_1267293 = _1267293;
l1267291: ;
_1267293 = p_1267293;
_1267296 = blockDim_y();
p_1267296 = _1267296;
l1267294: ;
_1267296 = p_1267296;
_1267299 = blockIdx_y();
p_1267299 = _1267299;
l1267297: ;
_1267299 = p_1267299;
_1267302 = blockDim_y();
p_1267302 = _1267302;
l1267300: ;
_1267302 = p_1267302;
int _1267306;
_1267306 = _1030628_1267279.e3;
int _1267308;
_1267308 = _1267287 * _1267290;
int _1267303;
_1267303 = _1267296 * _1267299;
int gid_x_1267309;
gid_x_1267309 = _1267284 + _1267308;
int gid_y_1267304;
gid_y_1267304 = _1267293 + _1267303;
int _1267305;
_1267305 = 1 + gid_y_1267304;
int _1267307;
_1267307 = _1267305 * _1267306;
int _1267310;
_1267310 = _1267307 + gid_x_1267309;
int _1267311;
_1267311 = 128 + _1267310;
float* idx_1267312;
idx_1267312 = _1030627_1267278 + _1267311;
_1267315 = __ldg(idx_1267312);
p_1267315 = _1267315;
l1267313: ;
_1267315 = p_1267315;
int _1267316;
_1267316 = _1030625_1267276.e3;
int _1267323;
_1267323 = gid_y_1267304 * _1267306;
int _1267324;
_1267324 = _1267323 + gid_x_1267309;
int _1267317;
_1267317 = _1267305 * _1267316;
int _1267325;
_1267325 = 128 + _1267324;
int _1267318;
_1267318 = _1267317 + gid_x_1267309;
float* idx_1267326;
idx_1267326 = _1030627_1267278 + _1267325;
int _1267319;
_1267319 = 128 + _1267318;
float* idx_1267320;
idx_1267320 = _1030630_1267281 + _1267319;
float _1267321;
_1267321 = *idx_1267320;
_1267329 = __ldg(idx_1267326);
p_1267329 = _1267329;
l1267327: ;
_1267329 = p_1267329;
int _1267330;
_1267330 = 127 + _1267310;
float* idx_1267331;
idx_1267331 = _1030627_1267278 + _1267330;
_1267334 = __ldg(idx_1267331);
p_1267334 = _1267334;
l1267332: ;
_1267334 = p_1267334;
int _1267335;
_1267335 = 129 + _1267310;
float* idx_1267336;
idx_1267336 = _1030627_1267278 + _1267335;
_1267339 = __ldg(idx_1267336);
p_1267339 = _1267339;
l1267337: ;
_1267339 = p_1267339;
int _1267340;
_1267340 = 2 + gid_y_1267304;
int _1267341;
_1267341 = _1267340 * _1267306;
int _1267342;
_1267342 = _1267341 + gid_x_1267309;
int _1267343;
_1267343 = 128 + _1267342;
float* idx_1267344;
idx_1267344 = _1030627_1267278 + _1267343;
_1267347 = __ldg(idx_1267344);
p_1267347 = _1267347;
l1267345: ;
_1267347 = p_1267347;
float _1267363;
_1267363 = 2.500000e-01f * _1267347;
float _1267361;
_1267361 = 2.500000e-01f * _1267339;
float _1267359;
_1267359 = 2.500000e-01f * _1267334;
float _1267353;
_1267353 = 2.000000e-01f * _1267315;
float _1267357;
_1267357 = 2.500000e-01f * _1267329;
float _1267354;
_1267354 = _1267321;
float _1267358;
_1267358 = 0.000000e+00f + _1267357;
int _1267348;
_1267348 = _1030629_1267280.e3;
float _1267360;
_1267360 = _1267358 + _1267359;
float _1267355;
_1267355 = 2.000000e-01f * _1267354;
int _1267349;
_1267349 = _1267305 * _1267348;
float _1267362;
_1267362 = _1267360 + _1267361;
float _1267356;
_1267356 = _1267353 + _1267355;
int _1267350;
_1267350 = _1267349 + gid_x_1267309;
float _1267364;
_1267364 = _1267362 + _1267363;
float val_1267365;
val_1267365 = _1267356 + _1267364;
int _1267351;
_1267351 = 128 + _1267350;
float* idx_1267352;
idx_1267352 = _1030626_1267277 + _1267351;
*idx_1267352 = val_1267365;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1028251(float* _1028254_1276127, float* _1028255_1276128, struct_Img_220118 _1028256_1276129, struct_Img_220118 _1028257_1276130) {
int threadIdx_x_1276133;
int pthreadIdx_x_1276133;
int blockDim_x_1276136;
int pblockDim_x_1276136;
int blockIdx_x_1276139;
int pblockIdx_x_1276139;
int _1276142;
int p_1276142;
int _1276145;
int p_1276145;
int _1276148;
int p_1276148;
int _1276151;
int p_1276151;
float _1276170;
float p_1276170;
float _1276178;
float p_1276178;
float _1276188;
float p_1276188;
float _1276195;
float p_1276195;
threadIdx_x_1276133 = threadIdx_x();
pthreadIdx_x_1276133 = threadIdx_x_1276133;
l1276131: ;
threadIdx_x_1276133 = pthreadIdx_x_1276133;
blockDim_x_1276136 = blockDim_x();
pblockDim_x_1276136 = blockDim_x_1276136;
l1276134: ;
blockDim_x_1276136 = pblockDim_x_1276136;
blockIdx_x_1276139 = blockIdx_x();
pblockIdx_x_1276139 = blockIdx_x_1276139;
l1276137: ;
blockIdx_x_1276139 = pblockIdx_x_1276139;
_1276142 = threadIdx_y();
p_1276142 = _1276142;
l1276140: ;
_1276142 = p_1276142;
_1276145 = blockDim_y();
p_1276145 = _1276145;
l1276143: ;
_1276145 = p_1276145;
_1276148 = blockIdx_y();
p_1276148 = _1276148;
l1276146: ;
_1276148 = p_1276148;
_1276151 = blockDim_y();
p_1276151 = _1276151;
l1276149: ;
_1276151 = p_1276151;
int _1276152;
_1276152 = _1276145 * _1276148;
int _1276156;
_1276156 = blockDim_x_1276136 * blockIdx_x_1276139;
int _1276162;
_1276162 = _1028256_1276129.e3;
int _1276157;
_1276157 = threadIdx_x_1276133 + _1276156;
int _1276154;
_1276154 = _1028257_1276130.e3;
int gid_y_1276153;
gid_y_1276153 = _1276142 + _1276152;
int _1276163;
_1276163 = gid_y_1276153 * _1276162;
int _1276165;
_1276165 = 2 * _1276157;
int _1276155;
_1276155 = gid_y_1276153 * _1276154;
int _1276164;
_1276164 = 2 * _1276163;
int _1276166;
_1276166 = _1276164 + _1276165;
int _1276158;
_1276158 = _1276155 + _1276157;
float* idx_1276167;
idx_1276167 = _1028254_1276127 + _1276166;
float* idx_1276159;
idx_1276159 = _1028255_1276128 + _1276158;
float _1276160;
_1276160 = *idx_1276159;
_1276170 = __ldg(idx_1276167);
p_1276170 = _1276170;
l1276168: ;
_1276170 = p_1276170;
float _1276171;
_1276171 = _1276160;
int _1276174;
_1276174 = 1 + _1276166;
float* idx_1276175;
idx_1276175 = _1028254_1276127 + _1276174;
float _1276172;
_1276172 = _1276170 + _1276171;
*idx_1276167 = _1276172;
_1276178 = __ldg(idx_1276175);
p_1276178 = _1276178;
l1276176: ;
_1276178 = p_1276178;
float _1276179;
_1276179 = _1276178 + _1276171;
int _1276181;
_1276181 = 2 * gid_y_1276153;
*idx_1276175 = _1276179;
int _1276182;
_1276182 = 1 + _1276181;
int _1276183;
_1276183 = _1276182 * _1276162;
int _1276184;
_1276184 = _1276183 + _1276165;
float* idx_1276185;
idx_1276185 = _1028254_1276127 + _1276184;
_1276188 = __ldg(idx_1276185);
p_1276188 = _1276188;
l1276186: ;
_1276188 = p_1276188;
float _1276189;
_1276189 = _1276188 + _1276171;
int _1276191;
_1276191 = 1 + _1276184;
float* idx_1276192;
idx_1276192 = _1028254_1276127 + _1276191;
*idx_1276185 = _1276189;
_1276195 = __ldg(idx_1276192);
p_1276195 = _1276195;
l1276193: ;
_1276195 = p_1276195;
float _1276196;
_1276196 = _1276195 + _1276171;
*idx_1276192 = _1276196;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1023817(struct_Img_220118 _1023820_1278343, float* _1023821_1278344, struct_Img_220118 _1023822_1278345, float* _1023823_1278346, float* _1023824_1278347, struct_Img_220118 _1023825_1278348) {
int _1278351;
int p_1278351;
int _1278354;
int p_1278354;
int _1278357;
int p_1278357;
int _1278360;
int p_1278360;
int _1278363;
int p_1278363;
int _1278366;
int p_1278366;
int _1278369;
int p_1278369;
struct_BoundaryMode_220129 bh_lower_1278376;
struct_BoundaryMode_220129 pbh_lower_1278376;
struct_BoundaryMode_220129 bh_lower_1278383;
struct_BoundaryMode_220129 pbh_lower_1278383;
float _1278400;
float p_1278400;
float _1278403;
float p_1278403;
struct_BoundaryMode_220129 bh_lower_1278407;
struct_BoundaryMode_220129 pbh_lower_1278407;
struct_BoundaryMode_220129 bh_lower_1278413;
struct_BoundaryMode_220129 pbh_lower_1278413;
float _1278429;
float p_1278429;
float _1278432;
float p_1278432;
struct_BoundaryMode_220129 bh_lower_1278438;
struct_BoundaryMode_220129 pbh_lower_1278438;
struct_BoundaryMode_220129 bh_lower_1278442;
struct_BoundaryMode_220129 pbh_lower_1278442;
float _1278458;
float p_1278458;
float _1278461;
float p_1278461;
struct_BoundaryMode_220129 bh_lower_1278467;
struct_BoundaryMode_220129 pbh_lower_1278467;
struct_BoundaryMode_220129 bh_lower_1278471;
struct_BoundaryMode_220129 pbh_lower_1278471;
float _1278487;
float p_1278487;
float _1278490;
float p_1278490;
struct_BoundaryMode_220129 bh_lower_1278494;
struct_BoundaryMode_220129 pbh_lower_1278494;
struct_BoundaryMode_220129 bh_lower_1278500;
struct_BoundaryMode_220129 pbh_lower_1278500;
float _1278516;
float p_1278516;
float _1278519;
float p_1278519;
_1278351 = threadIdx_x();
p_1278351 = _1278351;
l1278349: ;
_1278351 = p_1278351;
_1278354 = blockDim_x();
p_1278354 = _1278354;
l1278352: ;
_1278354 = p_1278354;
_1278357 = blockIdx_x();
p_1278357 = _1278357;
l1278355: ;
_1278357 = p_1278357;
_1278360 = threadIdx_y();
p_1278360 = _1278360;
l1278358: ;
_1278360 = p_1278360;
_1278363 = blockDim_y();
p_1278363 = _1278363;
l1278361: ;
_1278363 = p_1278363;
_1278366 = blockIdx_y();
p_1278366 = _1278366;
l1278364: ;
_1278366 = p_1278366;
_1278369 = blockDim_y();
p_1278369 = _1278369;
l1278367: ;
_1278369 = p_1278369;
int _1278370;
_1278370 = _1278354 * _1278357;
int gid_x_1278371;
gid_x_1278371 = _1278351 + _1278370;
union variant_220130 _1278556;
_1278556.qs32 = gid_x_1278371;
bool _1278372;
_1278372 = gid_x_1278371 < 0;
struct_BoundaryMode_220129 _1278557;
_1278557.e0 = 0;
_1278557.e1 = _1278556;
if (_1278372) goto l1278373; else goto l1278610;
l1278610: ;
pbh_lower_1278376 = _1278557;
goto l1278374;
l1278373: ;
union variant_220130 _1265919_9476;
_1265919_9476.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9478;
_1265920_9478.e0 = 1;
_1265920_9478.e1 = _1265919_9476;
pbh_lower_1278376 = _1265920_9478;
goto l1278374;
l1278374: ;
bh_lower_1278376 = pbh_lower_1278376;
int _1278377;
_1278377 = _1278363 * _1278366;
int gid_y_1278378;
gid_y_1278378 = _1278360 + _1278377;
bool _1278379;
_1278379 = gid_y_1278378 < 0;
union variant_220130 _1278568;
_1278568.qs32 = gid_y_1278378;
struct_BoundaryMode_220129 _1278569;
_1278569.e0 = 0;
_1278569.e1 = _1278568;
if (_1278379) goto l1278380; else goto l1278609;
l1278609: ;
pbh_lower_1278383 = _1278569;
goto l1278381;
l1278380: ;
union variant_220130 _1265919_9486;
_1265919_9486.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9488;
_1265920_9488.e0 = 1;
_1265920_9488.e1 = _1265919_9486;
pbh_lower_1278383 = _1265920_9488;
goto l1278381;
l1278381: ;
bh_lower_1278383 = pbh_lower_1278383;
unsigned int _1278386;
_1278386 = bh_lower_1278383.e0;
union variant_220130 _1278390;
_1278390 = bh_lower_1278383.e1;
int _1278392;
_1278392 = _1023820_1278343.e3;
bool _1278387;
_1278387 = _1278386 == 0;
unsigned int _1278384;
_1278384 = bh_lower_1278376.e0;
union variant_220130 _1278394;
_1278394 = bh_lower_1278376.e1;
bool _1278385;
_1278385 = _1278384 == 0;
bool _1278388;
_1278388 = _1278385 & _1278387;
if (_1278388) goto l1278389; else goto l1278600;
l1278600: ;
bool _1278601;
_1278601 = _1278384 == 1;
if (_1278601) goto l1278602; else goto l1278604;
l1278604: ;
bool _1278605;
_1278605 = _1278386 == 1;
if (_1278605) goto l1278606; else goto l1278608;
l1278608: ;
// bottom: float r4_1265918_9501;
// bottom: p_1278403 = r4_1265918_9501;
goto l1278401;
l1278606: ;
float c_1278607;
c_1278607 = _1278390.pf32;
p_1278403 = c_1278607;
goto l1278401;
l1278602: ;
float c_1278603;
c_1278603 = _1278394.pf32;
p_1278403 = c_1278603;
goto l1278401;
l1278389: ;
int x_1278395;
x_1278395 = _1278394.qs32;
int y_1278391;
y_1278391 = _1278390.qs32;
int _1278393;
_1278393 = y_1278391 * _1278392;
int _1278396;
_1278396 = _1278393 + x_1278395;
float* idx_1278397;
idx_1278397 = _1023823_1278346 + _1278396;
_1278400 = __ldg(idx_1278397);
p_1278400 = _1278400;
l1278398: ;
_1278400 = p_1278400;
p_1278403 = _1278400;
goto l1278401;
l1278401: ;
_1278403 = p_1278403;
int _1278525;
_1278525 = _1023825_1278348.e3;
int _1278526;
_1278526 = gid_y_1278378 * _1278525;
int _1278527;
_1278527 = _1278526 + gid_x_1278371;
float* idx_1278528;
idx_1278528 = _1023821_1278344 + _1278527;
float _1278529;
_1278529 = *idx_1278528;
if (_1278372) goto l1278404; else goto l1278599;
l1278599: ;
pbh_lower_1278407 = _1278557;
goto l1278405;
l1278404: ;
union variant_220130 _1265919_9503;
_1265919_9503.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9505;
_1265920_9505.e0 = 1;
_1265920_9505.e1 = _1265919_9503;
pbh_lower_1278407 = _1265920_9505;
goto l1278405;
l1278405: ;
bh_lower_1278407 = pbh_lower_1278407;
int _1278408;
_1278408 = -1 + gid_y_1278378;
bool _1278409;
_1278409 = _1278408 < 0;
if (_1278409) goto l1278410; else goto l1278595;
l1278595: ;
union variant_220130 _1278596;
_1278596.qs32 = _1278408;
struct_BoundaryMode_220129 _1278597;
_1278597.e0 = 0;
_1278597.e1 = _1278596;
pbh_lower_1278413 = _1278597;
goto l1278411;
l1278410: ;
union variant_220130 _1265919_9514;
_1265919_9514.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9516;
_1265920_9516.e0 = 1;
_1265920_9516.e1 = _1265919_9514;
pbh_lower_1278413 = _1265920_9516;
goto l1278411;
l1278411: ;
bh_lower_1278413 = pbh_lower_1278413;
union variant_220130 _1278423;
_1278423 = bh_lower_1278407.e1;
unsigned int _1278416;
_1278416 = bh_lower_1278413.e0;
unsigned int _1278414;
_1278414 = bh_lower_1278407.e0;
union variant_220130 _1278420;
_1278420 = bh_lower_1278413.e1;
bool _1278415;
_1278415 = _1278414 == 0;
bool _1278417;
_1278417 = _1278416 == 0;
bool _1278418;
_1278418 = _1278415 & _1278417;
if (_1278418) goto l1278419; else goto l1278586;
l1278586: ;
bool _1278587;
_1278587 = _1278414 == 1;
if (_1278587) goto l1278588; else goto l1278590;
l1278590: ;
bool _1278591;
_1278591 = _1278416 == 1;
if (_1278591) goto l1278592; else goto l1278594;
l1278594: ;
// bottom: float r4_1265918_9528;
// bottom: p_1278432 = r4_1265918_9528;
goto l1278430;
l1278592: ;
float c_1278593;
c_1278593 = _1278420.pf32;
p_1278432 = c_1278593;
goto l1278430;
l1278588: ;
float c_1278589;
c_1278589 = _1278423.pf32;
p_1278432 = c_1278589;
goto l1278430;
l1278419: ;
int x_1278424;
x_1278424 = _1278423.qs32;
int y_1278421;
y_1278421 = _1278420.qs32;
int _1278422;
_1278422 = y_1278421 * _1278392;
int _1278425;
_1278425 = _1278422 + x_1278424;
float* idx_1278426;
idx_1278426 = _1023823_1278346 + _1278425;
_1278429 = __ldg(idx_1278426);
p_1278429 = _1278429;
l1278427: ;
_1278429 = p_1278429;
p_1278432 = _1278429;
goto l1278430;
l1278430: ;
_1278432 = p_1278432;
int _1278433;
_1278433 = -1 + gid_x_1278371;
bool _1278434;
_1278434 = _1278433 < 0;
if (_1278434) goto l1278435; else goto l1278583;
l1278583: ;
union variant_220130 _1278584;
_1278584.qs32 = _1278433;
struct_BoundaryMode_220129 _1278585;
_1278585.e0 = 0;
_1278585.e1 = _1278584;
pbh_lower_1278438 = _1278585;
goto l1278436;
l1278435: ;
union variant_220130 _1265919_9534;
_1265919_9534.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9536;
_1265920_9536.e0 = 1;
_1265920_9536.e1 = _1265919_9534;
pbh_lower_1278438 = _1265920_9536;
goto l1278436;
l1278436: ;
bh_lower_1278438 = pbh_lower_1278438;
if (_1278379) goto l1278439; else goto l1278582;
l1278582: ;
pbh_lower_1278442 = _1278569;
goto l1278440;
l1278439: ;
union variant_220130 _1265919_9540;
_1265919_9540.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9542;
_1265920_9542.e0 = 1;
_1265920_9542.e1 = _1265919_9540;
pbh_lower_1278442 = _1265920_9542;
goto l1278440;
l1278440: ;
bh_lower_1278442 = pbh_lower_1278442;
unsigned int _1278443;
_1278443 = bh_lower_1278438.e0;
union variant_220130 _1278449;
_1278449 = bh_lower_1278442.e1;
union variant_220130 _1278452;
_1278452 = bh_lower_1278438.e1;
unsigned int _1278445;
_1278445 = bh_lower_1278442.e0;
bool _1278444;
_1278444 = _1278443 == 0;
bool _1278446;
_1278446 = _1278445 == 0;
bool _1278447;
_1278447 = _1278444 & _1278446;
if (_1278447) goto l1278448; else goto l1278573;
l1278573: ;
bool _1278574;
_1278574 = _1278443 == 1;
if (_1278574) goto l1278575; else goto l1278577;
l1278577: ;
bool _1278578;
_1278578 = _1278445 == 1;
if (_1278578) goto l1278579; else goto l1278581;
l1278581: ;
// bottom: float r4_1265918_9554;
// bottom: p_1278461 = r4_1265918_9554;
goto l1278459;
l1278579: ;
float c_1278580;
c_1278580 = _1278449.pf32;
p_1278461 = c_1278580;
goto l1278459;
l1278575: ;
float c_1278576;
c_1278576 = _1278452.pf32;
p_1278461 = c_1278576;
goto l1278459;
l1278448: ;
int y_1278450;
y_1278450 = _1278449.qs32;
int x_1278453;
x_1278453 = _1278452.qs32;
int _1278451;
_1278451 = y_1278450 * _1278392;
int _1278454;
_1278454 = _1278451 + x_1278453;
float* idx_1278455;
idx_1278455 = _1023823_1278346 + _1278454;
_1278458 = __ldg(idx_1278455);
p_1278458 = _1278458;
l1278456: ;
_1278458 = p_1278458;
p_1278461 = _1278458;
goto l1278459;
l1278459: ;
_1278461 = p_1278461;
int _1278462;
_1278462 = 1 + gid_x_1278371;
bool _1278463;
_1278463 = _1278462 < 0;
if (_1278463) goto l1278464; else goto l1278570;
l1278570: ;
union variant_220130 _1278571;
_1278571.qs32 = _1278462;
struct_BoundaryMode_220129 _1278572;
_1278572.e0 = 0;
_1278572.e1 = _1278571;
pbh_lower_1278467 = _1278572;
goto l1278465;
l1278464: ;
union variant_220130 _1265919_9560;
_1265919_9560.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9562;
_1265920_9562.e0 = 1;
_1265920_9562.e1 = _1265919_9560;
pbh_lower_1278467 = _1265920_9562;
goto l1278465;
l1278465: ;
bh_lower_1278467 = pbh_lower_1278467;
if (_1278379) goto l1278468; else goto l1278567;
l1278567: ;
pbh_lower_1278471 = _1278569;
goto l1278469;
l1278468: ;
union variant_220130 _1265919_9566;
_1265919_9566.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9568;
_1265920_9568.e0 = 1;
_1265920_9568.e1 = _1265919_9566;
pbh_lower_1278471 = _1265920_9568;
goto l1278469;
l1278469: ;
bh_lower_1278471 = pbh_lower_1278471;
union variant_220130 _1278481;
_1278481 = bh_lower_1278467.e1;
unsigned int _1278472;
_1278472 = bh_lower_1278467.e0;
unsigned int _1278474;
_1278474 = bh_lower_1278471.e0;
union variant_220130 _1278478;
_1278478 = bh_lower_1278471.e1;
bool _1278473;
_1278473 = _1278472 == 0;
bool _1278475;
_1278475 = _1278474 == 0;
bool _1278476;
_1278476 = _1278473 & _1278475;
if (_1278476) goto l1278477; else goto l1278558;
l1278558: ;
bool _1278559;
_1278559 = _1278472 == 1;
if (_1278559) goto l1278560; else goto l1278562;
l1278562: ;
bool _1278563;
_1278563 = _1278474 == 1;
if (_1278563) goto l1278564; else goto l1278566;
l1278566: ;
// bottom: float r4_1265918_9580;
// bottom: p_1278490 = r4_1265918_9580;
goto l1278488;
l1278564: ;
float c_1278565;
c_1278565 = _1278478.pf32;
p_1278490 = c_1278565;
goto l1278488;
l1278560: ;
float c_1278561;
c_1278561 = _1278481.pf32;
p_1278490 = c_1278561;
goto l1278488;
l1278477: ;
int x_1278482;
x_1278482 = _1278481.qs32;
int y_1278479;
y_1278479 = _1278478.qs32;
int _1278480;
_1278480 = y_1278479 * _1278392;
int _1278483;
_1278483 = _1278480 + x_1278482;
float* idx_1278484;
idx_1278484 = _1023823_1278346 + _1278483;
_1278487 = __ldg(idx_1278484);
p_1278487 = _1278487;
l1278485: ;
_1278487 = p_1278487;
p_1278490 = _1278487;
goto l1278488;
l1278488: ;
_1278490 = p_1278490;
if (_1278372) goto l1278491; else goto l1278555;
l1278555: ;
pbh_lower_1278494 = _1278557;
goto l1278492;
l1278491: ;
union variant_220130 _1265919_9581;
_1265919_9581.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9583;
_1265920_9583.e0 = 1;
_1265920_9583.e1 = _1265919_9581;
pbh_lower_1278494 = _1265920_9583;
goto l1278492;
l1278492: ;
bh_lower_1278494 = pbh_lower_1278494;
int _1278495;
_1278495 = 1 + gid_y_1278378;
bool _1278496;
_1278496 = _1278495 < 0;
if (_1278496) goto l1278497; else goto l1278552;
l1278552: ;
union variant_220130 _1278553;
_1278553.qs32 = _1278495;
struct_BoundaryMode_220129 _1278554;
_1278554.e0 = 0;
_1278554.e1 = _1278553;
pbh_lower_1278500 = _1278554;
goto l1278498;
l1278497: ;
union variant_220130 _1265919_9592;
_1265919_9592.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9594;
_1265920_9594.e0 = 1;
_1265920_9594.e1 = _1265919_9592;
pbh_lower_1278500 = _1265920_9594;
goto l1278498;
l1278498: ;
bh_lower_1278500 = pbh_lower_1278500;
union variant_220130 _1278510;
_1278510 = bh_lower_1278494.e1;
union variant_220130 _1278507;
_1278507 = bh_lower_1278500.e1;
unsigned int _1278503;
_1278503 = bh_lower_1278500.e0;
unsigned int _1278501;
_1278501 = bh_lower_1278494.e0;
bool _1278504;
_1278504 = _1278503 == 0;
bool _1278502;
_1278502 = _1278501 == 0;
bool _1278505;
_1278505 = _1278502 & _1278504;
if (_1278505) goto l1278506; else goto l1278543;
l1278543: ;
bool _1278544;
_1278544 = _1278501 == 1;
if (_1278544) goto l1278545; else goto l1278547;
l1278547: ;
bool _1278548;
_1278548 = _1278503 == 1;
if (_1278548) goto l1278549; else goto l1278551;
l1278551: ;
// bottom: float r4_1265918_9606;
// bottom: p_1278519 = r4_1265918_9606;
goto l1278517;
l1278549: ;
float c_1278550;
c_1278550 = _1278507.pf32;
p_1278519 = c_1278550;
goto l1278517;
l1278545: ;
float c_1278546;
c_1278546 = _1278510.pf32;
p_1278519 = c_1278546;
goto l1278517;
l1278506: ;
int x_1278511;
x_1278511 = _1278510.qs32;
int y_1278508;
y_1278508 = _1278507.qs32;
int _1278509;
_1278509 = y_1278508 * _1278392;
int _1278512;
_1278512 = _1278509 + x_1278511;
float* idx_1278513;
idx_1278513 = _1023823_1278346 + _1278512;
_1278516 = __ldg(idx_1278513);
p_1278516 = _1278516;
l1278514: ;
_1278516 = p_1278516;
p_1278519 = _1278516;
goto l1278517;
l1278517: ;
_1278519 = p_1278519;
float _1278524;
_1278524 = 2.000000e-01f * _1278403;
float _1278533;
_1278533 = 2.500000e-01f * _1278432;
float _1278535;
_1278535 = 2.500000e-01f * _1278461;
int _1278520;
_1278520 = _1023822_1278345.e3;
int _1278521;
_1278521 = gid_y_1278378 * _1278520;
float _1278539;
_1278539 = 2.500000e-01f * _1278519;
float _1278530;
_1278530 = _1278529;
float _1278537;
_1278537 = 2.500000e-01f * _1278490;
float _1278534;
_1278534 = 0.000000e+00f + _1278533;
float _1278536;
_1278536 = _1278534 + _1278535;
int _1278522;
_1278522 = _1278521 + gid_x_1278371;
float _1278531;
_1278531 = 2.000000e-01f * _1278530;
float _1278538;
_1278538 = _1278536 + _1278537;
float* idx_1278523;
idx_1278523 = _1023824_1278347 + _1278522;
float _1278532;
_1278532 = _1278524 + _1278531;
float _1278540;
_1278540 = _1278538 + _1278539;
float val_1278541;
val_1278541 = _1278532 + _1278540;
*idx_1278523 = val_1278541;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1026662(struct_Img_220118 _1026665_1282493, float* _1026666_1282494, struct_Img_220118 _1026667_1282495, float* _1026668_1282496, float* _1026669_1282497, struct_Img_220118 _1026670_1282498) {
int _1282501;
int p_1282501;
int _1282504;
int p_1282504;
int _1282507;
int p_1282507;
int _1282510;
int p_1282510;
int _1282513;
int p_1282513;
int _1282516;
int p_1282516;
int _1282519;
int p_1282519;
struct_BoundaryMode_220129 bh_upper_1282530;
struct_BoundaryMode_220129 pbh_upper_1282530;
struct_BoundaryMode_220129 bh_lower_1282537;
struct_BoundaryMode_220129 pbh_lower_1282537;
float _1282554;
float p_1282554;
float _1282557;
float p_1282557;
struct_BoundaryMode_220129 bh_upper_1282561;
struct_BoundaryMode_220129 pbh_upper_1282561;
struct_BoundaryMode_220129 bh_lower_1282567;
struct_BoundaryMode_220129 pbh_lower_1282567;
float _1282583;
float p_1282583;
float _1282586;
float p_1282586;
struct_BoundaryMode_220129 bh_upper_1282592;
struct_BoundaryMode_220129 pbh_upper_1282592;
struct_BoundaryMode_220129 bh_lower_1282596;
struct_BoundaryMode_220129 pbh_lower_1282596;
float _1282612;
float p_1282612;
float _1282615;
float p_1282615;
struct_BoundaryMode_220129 bh_upper_1282621;
struct_BoundaryMode_220129 pbh_upper_1282621;
struct_BoundaryMode_220129 bh_lower_1282625;
struct_BoundaryMode_220129 pbh_lower_1282625;
float _1282641;
float p_1282641;
float _1282644;
float p_1282644;
struct_BoundaryMode_220129 bh_upper_1282648;
struct_BoundaryMode_220129 pbh_upper_1282648;
struct_BoundaryMode_220129 bh_lower_1282654;
struct_BoundaryMode_220129 pbh_lower_1282654;
float _1282670;
float p_1282670;
float _1282673;
float p_1282673;
_1282501 = threadIdx_x();
p_1282501 = _1282501;
l1282499: ;
_1282501 = p_1282501;
_1282504 = blockDim_x();
p_1282504 = _1282504;
l1282502: ;
_1282504 = p_1282504;
_1282507 = blockIdx_x();
p_1282507 = _1282507;
l1282505: ;
_1282507 = p_1282507;
_1282510 = threadIdx_y();
p_1282510 = _1282510;
l1282508: ;
_1282510 = p_1282510;
_1282513 = blockDim_y();
p_1282513 = _1282513;
l1282511: ;
_1282513 = p_1282513;
_1282516 = blockIdx_y();
p_1282516 = _1282516;
l1282514: ;
_1282516 = p_1282516;
_1282519 = blockDim_y();
p_1282519 = _1282519;
l1282517: ;
_1282519 = p_1282519;
int _1282520;
_1282520 = _1026665_1282493.e1;
int _1282524;
_1282524 = _1282504 * _1282507;
int _1282521;
_1282521 = _1026667_1282495.e1;
int _1282522;
_1282522 = _1282521 - 128;
int _1282523;
_1282523 = _1282522 + _1282501;
int gid_x_1282525;
gid_x_1282525 = _1282523 + _1282524;
bool _1282526;
_1282526 = _1282520 <= gid_x_1282525;
union variant_220130 _1282710;
_1282710.qs32 = gid_x_1282525;
struct_BoundaryMode_220129 _1282711;
_1282711.e0 = 0;
_1282711.e1 = _1282710;
if (_1282526) goto l1282527; else goto l1282764;
l1282764: ;
pbh_upper_1282530 = _1282711;
goto l1282528;
l1282527: ;
union variant_220130 _1265919_9621;
_1265919_9621.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9623;
_1265920_9623.e0 = 1;
_1265920_9623.e1 = _1265919_9621;
pbh_upper_1282530 = _1265920_9623;
goto l1282528;
l1282528: ;
bh_upper_1282530 = pbh_upper_1282530;
int _1282531;
_1282531 = _1282513 * _1282516;
int gid_y_1282532;
gid_y_1282532 = _1282510 + _1282531;
union variant_220130 _1282722;
_1282722.qs32 = gid_y_1282532;
bool _1282533;
_1282533 = gid_y_1282532 < 0;
struct_BoundaryMode_220129 _1282723;
_1282723.e0 = 0;
_1282723.e1 = _1282722;
if (_1282533) goto l1282534; else goto l1282763;
l1282763: ;
pbh_lower_1282537 = _1282723;
goto l1282535;
l1282534: ;
union variant_220130 _1265919_9631;
_1265919_9631.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9633;
_1265920_9633.e0 = 1;
_1265920_9633.e1 = _1265919_9631;
pbh_lower_1282537 = _1265920_9633;
goto l1282535;
l1282535: ;
bh_lower_1282537 = pbh_lower_1282537;
union variant_220130 _1282544;
_1282544 = bh_lower_1282537.e1;
union variant_220130 _1282548;
_1282548 = bh_upper_1282530.e1;
int _1282546;
_1282546 = _1026665_1282493.e3;
unsigned int _1282538;
_1282538 = bh_upper_1282530.e0;
unsigned int _1282540;
_1282540 = bh_lower_1282537.e0;
bool _1282539;
_1282539 = _1282538 == 0;
bool _1282541;
_1282541 = _1282540 == 0;
bool _1282542;
_1282542 = _1282539 & _1282541;
if (_1282542) goto l1282543; else goto l1282754;
l1282754: ;
bool _1282755;
_1282755 = _1282538 == 1;
if (_1282755) goto l1282756; else goto l1282758;
l1282758: ;
bool _1282759;
_1282759 = _1282540 == 1;
if (_1282759) goto l1282760; else goto l1282762;
l1282762: ;
// bottom: float r4_1265918_9646;
// bottom: p_1282557 = r4_1265918_9646;
goto l1282555;
l1282760: ;
float c_1282761;
c_1282761 = _1282544.pf32;
p_1282557 = c_1282761;
goto l1282555;
l1282756: ;
float c_1282757;
c_1282757 = _1282548.pf32;
p_1282557 = c_1282757;
goto l1282555;
l1282543: ;
int y_1282545;
y_1282545 = _1282544.qs32;
int x_1282549;
x_1282549 = _1282548.qs32;
int _1282547;
_1282547 = y_1282545 * _1282546;
int _1282550;
_1282550 = _1282547 + x_1282549;
float* idx_1282551;
idx_1282551 = _1026668_1282496 + _1282550;
_1282554 = __ldg(idx_1282551);
p_1282554 = _1282554;
l1282552: ;
_1282554 = p_1282554;
p_1282557 = _1282554;
goto l1282555;
l1282555: ;
_1282557 = p_1282557;
int _1282679;
_1282679 = _1026670_1282498.e3;
int _1282680;
_1282680 = gid_y_1282532 * _1282679;
int _1282681;
_1282681 = _1282680 + gid_x_1282525;
float* idx_1282682;
idx_1282682 = _1026666_1282494 + _1282681;
float _1282683;
_1282683 = *idx_1282682;
if (_1282526) goto l1282558; else goto l1282753;
l1282753: ;
pbh_upper_1282561 = _1282711;
goto l1282559;
l1282558: ;
union variant_220130 _1265919_9648;
_1265919_9648.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9650;
_1265920_9650.e0 = 1;
_1265920_9650.e1 = _1265919_9648;
pbh_upper_1282561 = _1265920_9650;
goto l1282559;
l1282559: ;
bh_upper_1282561 = pbh_upper_1282561;
int _1282562;
_1282562 = -1 + gid_y_1282532;
bool _1282563;
_1282563 = _1282562 < 0;
if (_1282563) goto l1282564; else goto l1282749;
l1282749: ;
union variant_220130 _1282750;
_1282750.qs32 = _1282562;
struct_BoundaryMode_220129 _1282751;
_1282751.e0 = 0;
_1282751.e1 = _1282750;
pbh_lower_1282567 = _1282751;
goto l1282565;
l1282564: ;
union variant_220130 _1265919_9659;
_1265919_9659.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9661;
_1265920_9661.e0 = 1;
_1265920_9661.e1 = _1265919_9659;
pbh_lower_1282567 = _1265920_9661;
goto l1282565;
l1282565: ;
bh_lower_1282567 = pbh_lower_1282567;
unsigned int _1282570;
_1282570 = bh_lower_1282567.e0;
union variant_220130 _1282574;
_1282574 = bh_lower_1282567.e1;
union variant_220130 _1282577;
_1282577 = bh_upper_1282561.e1;
bool _1282571;
_1282571 = _1282570 == 0;
unsigned int _1282568;
_1282568 = bh_upper_1282561.e0;
bool _1282569;
_1282569 = _1282568 == 0;
bool _1282572;
_1282572 = _1282569 & _1282571;
if (_1282572) goto l1282573; else goto l1282740;
l1282740: ;
bool _1282741;
_1282741 = _1282568 == 1;
if (_1282741) goto l1282742; else goto l1282744;
l1282744: ;
bool _1282745;
_1282745 = _1282570 == 1;
if (_1282745) goto l1282746; else goto l1282748;
l1282748: ;
// bottom: float r4_1265918_9673;
// bottom: p_1282586 = r4_1265918_9673;
goto l1282584;
l1282746: ;
float c_1282747;
c_1282747 = _1282574.pf32;
p_1282586 = c_1282747;
goto l1282584;
l1282742: ;
float c_1282743;
c_1282743 = _1282577.pf32;
p_1282586 = c_1282743;
goto l1282584;
l1282573: ;
int y_1282575;
y_1282575 = _1282574.qs32;
int _1282576;
_1282576 = y_1282575 * _1282546;
int x_1282578;
x_1282578 = _1282577.qs32;
int _1282579;
_1282579 = _1282576 + x_1282578;
float* idx_1282580;
idx_1282580 = _1026668_1282496 + _1282579;
_1282583 = __ldg(idx_1282580);
p_1282583 = _1282583;
l1282581: ;
_1282583 = p_1282583;
p_1282586 = _1282583;
goto l1282584;
l1282584: ;
_1282586 = p_1282586;
int _1282587;
_1282587 = -1 + gid_x_1282525;
bool _1282588;
_1282588 = _1282520 <= _1282587;
if (_1282588) goto l1282589; else goto l1282737;
l1282737: ;
union variant_220130 _1282738;
_1282738.qs32 = _1282587;
struct_BoundaryMode_220129 _1282739;
_1282739.e0 = 0;
_1282739.e1 = _1282738;
pbh_upper_1282592 = _1282739;
goto l1282590;
l1282589: ;
union variant_220130 _1265919_9678;
_1265919_9678.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9680;
_1265920_9680.e0 = 1;
_1265920_9680.e1 = _1265919_9678;
pbh_upper_1282592 = _1265920_9680;
goto l1282590;
l1282590: ;
bh_upper_1282592 = pbh_upper_1282592;
if (_1282533) goto l1282593; else goto l1282736;
l1282736: ;
pbh_lower_1282596 = _1282723;
goto l1282594;
l1282593: ;
union variant_220130 _1265919_9684;
_1265919_9684.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9686;
_1265920_9686.e0 = 1;
_1265920_9686.e1 = _1265919_9684;
pbh_lower_1282596 = _1265920_9686;
goto l1282594;
l1282594: ;
bh_lower_1282596 = pbh_lower_1282596;
unsigned int _1282599;
_1282599 = bh_lower_1282596.e0;
bool _1282600;
_1282600 = _1282599 == 0;
unsigned int _1282597;
_1282597 = bh_upper_1282592.e0;
union variant_220130 _1282606;
_1282606 = bh_upper_1282592.e1;
union variant_220130 _1282603;
_1282603 = bh_lower_1282596.e1;
bool _1282598;
_1282598 = _1282597 == 0;
bool _1282601;
_1282601 = _1282598 & _1282600;
if (_1282601) goto l1282602; else goto l1282727;
l1282727: ;
bool _1282728;
_1282728 = _1282597 == 1;
if (_1282728) goto l1282729; else goto l1282731;
l1282731: ;
bool _1282732;
_1282732 = _1282599 == 1;
if (_1282732) goto l1282733; else goto l1282735;
l1282735: ;
// bottom: float r4_1265918_9698;
// bottom: p_1282615 = r4_1265918_9698;
goto l1282613;
l1282733: ;
float c_1282734;
c_1282734 = _1282603.pf32;
p_1282615 = c_1282734;
goto l1282613;
l1282729: ;
float c_1282730;
c_1282730 = _1282606.pf32;
p_1282615 = c_1282730;
goto l1282613;
l1282602: ;
int x_1282607;
x_1282607 = _1282606.qs32;
int y_1282604;
y_1282604 = _1282603.qs32;
int _1282605;
_1282605 = y_1282604 * _1282546;
int _1282608;
_1282608 = _1282605 + x_1282607;
float* idx_1282609;
idx_1282609 = _1026668_1282496 + _1282608;
_1282612 = __ldg(idx_1282609);
p_1282612 = _1282612;
l1282610: ;
_1282612 = p_1282612;
p_1282615 = _1282612;
goto l1282613;
l1282613: ;
_1282615 = p_1282615;
int _1282616;
_1282616 = 1 + gid_x_1282525;
bool _1282617;
_1282617 = _1282520 <= _1282616;
if (_1282617) goto l1282618; else goto l1282724;
l1282724: ;
union variant_220130 _1282725;
_1282725.qs32 = _1282616;
struct_BoundaryMode_220129 _1282726;
_1282726.e0 = 0;
_1282726.e1 = _1282725;
pbh_upper_1282621 = _1282726;
goto l1282619;
l1282618: ;
union variant_220130 _1265919_9703;
_1265919_9703.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9705;
_1265920_9705.e0 = 1;
_1265920_9705.e1 = _1265919_9703;
pbh_upper_1282621 = _1265920_9705;
goto l1282619;
l1282619: ;
bh_upper_1282621 = pbh_upper_1282621;
if (_1282533) goto l1282622; else goto l1282721;
l1282721: ;
pbh_lower_1282625 = _1282723;
goto l1282623;
l1282622: ;
union variant_220130 _1265919_9709;
_1265919_9709.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9711;
_1265920_9711.e0 = 1;
_1265920_9711.e1 = _1265919_9709;
pbh_lower_1282625 = _1265920_9711;
goto l1282623;
l1282623: ;
bh_lower_1282625 = pbh_lower_1282625;
union variant_220130 _1282635;
_1282635 = bh_upper_1282621.e1;
unsigned int _1282628;
_1282628 = bh_lower_1282625.e0;
unsigned int _1282626;
_1282626 = bh_upper_1282621.e0;
bool _1282629;
_1282629 = _1282628 == 0;
bool _1282627;
_1282627 = _1282626 == 0;
union variant_220130 _1282632;
_1282632 = bh_lower_1282625.e1;
bool _1282630;
_1282630 = _1282627 & _1282629;
if (_1282630) goto l1282631; else goto l1282712;
l1282712: ;
bool _1282713;
_1282713 = _1282626 == 1;
if (_1282713) goto l1282714; else goto l1282716;
l1282716: ;
bool _1282717;
_1282717 = _1282628 == 1;
if (_1282717) goto l1282718; else goto l1282720;
l1282720: ;
// bottom: float r4_1265918_9723;
// bottom: p_1282644 = r4_1265918_9723;
goto l1282642;
l1282718: ;
float c_1282719;
c_1282719 = _1282632.pf32;
p_1282644 = c_1282719;
goto l1282642;
l1282714: ;
float c_1282715;
c_1282715 = _1282635.pf32;
p_1282644 = c_1282715;
goto l1282642;
l1282631: ;
int x_1282636;
x_1282636 = _1282635.qs32;
int y_1282633;
y_1282633 = _1282632.qs32;
int _1282634;
_1282634 = y_1282633 * _1282546;
int _1282637;
_1282637 = _1282634 + x_1282636;
float* idx_1282638;
idx_1282638 = _1026668_1282496 + _1282637;
_1282641 = __ldg(idx_1282638);
p_1282641 = _1282641;
l1282639: ;
_1282641 = p_1282641;
p_1282644 = _1282641;
goto l1282642;
l1282642: ;
_1282644 = p_1282644;
if (_1282526) goto l1282645; else goto l1282709;
l1282709: ;
pbh_upper_1282648 = _1282711;
goto l1282646;
l1282645: ;
union variant_220130 _1265919_9724;
_1265919_9724.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9726;
_1265920_9726.e0 = 1;
_1265920_9726.e1 = _1265919_9724;
pbh_upper_1282648 = _1265920_9726;
goto l1282646;
l1282646: ;
bh_upper_1282648 = pbh_upper_1282648;
int _1282649;
_1282649 = 1 + gid_y_1282532;
bool _1282650;
_1282650 = _1282649 < 0;
if (_1282650) goto l1282651; else goto l1282706;
l1282706: ;
union variant_220130 _1282707;
_1282707.qs32 = _1282649;
struct_BoundaryMode_220129 _1282708;
_1282708.e0 = 0;
_1282708.e1 = _1282707;
pbh_lower_1282654 = _1282708;
goto l1282652;
l1282651: ;
union variant_220130 _1265919_9735;
_1265919_9735.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9737;
_1265920_9737.e0 = 1;
_1265920_9737.e1 = _1265919_9735;
pbh_lower_1282654 = _1265920_9737;
goto l1282652;
l1282652: ;
bh_lower_1282654 = pbh_lower_1282654;
unsigned int _1282657;
_1282657 = bh_lower_1282654.e0;
unsigned int _1282655;
_1282655 = bh_upper_1282648.e0;
bool _1282656;
_1282656 = _1282655 == 0;
union variant_220130 _1282664;
_1282664 = bh_upper_1282648.e1;
bool _1282658;
_1282658 = _1282657 == 0;
union variant_220130 _1282661;
_1282661 = bh_lower_1282654.e1;
bool _1282659;
_1282659 = _1282656 & _1282658;
if (_1282659) goto l1282660; else goto l1282697;
l1282697: ;
bool _1282698;
_1282698 = _1282655 == 1;
if (_1282698) goto l1282699; else goto l1282701;
l1282701: ;
bool _1282702;
_1282702 = _1282657 == 1;
if (_1282702) goto l1282703; else goto l1282705;
l1282705: ;
// bottom: float r4_1265918_9749;
// bottom: p_1282673 = r4_1265918_9749;
goto l1282671;
l1282703: ;
float c_1282704;
c_1282704 = _1282661.pf32;
p_1282673 = c_1282704;
goto l1282671;
l1282699: ;
float c_1282700;
c_1282700 = _1282664.pf32;
p_1282673 = c_1282700;
goto l1282671;
l1282660: ;
int x_1282665;
x_1282665 = _1282664.qs32;
int y_1282662;
y_1282662 = _1282661.qs32;
int _1282663;
_1282663 = y_1282662 * _1282546;
int _1282666;
_1282666 = _1282663 + x_1282665;
float* idx_1282667;
idx_1282667 = _1026668_1282496 + _1282666;
_1282670 = __ldg(idx_1282667);
p_1282670 = _1282670;
l1282668: ;
_1282670 = p_1282670;
p_1282673 = _1282670;
goto l1282671;
l1282671: ;
_1282673 = p_1282673;
float _1282678;
_1282678 = 2.000000e-01f * _1282557;
float _1282689;
_1282689 = 2.500000e-01f * _1282615;
float _1282693;
_1282693 = 2.500000e-01f * _1282673;
float _1282684;
_1282684 = _1282683;
int _1282674;
_1282674 = _1026667_1282495.e3;
float _1282687;
_1282687 = 2.500000e-01f * _1282586;
float _1282691;
_1282691 = 2.500000e-01f * _1282644;
float _1282685;
_1282685 = 2.000000e-01f * _1282684;
int _1282675;
_1282675 = gid_y_1282532 * _1282674;
float _1282688;
_1282688 = 0.000000e+00f + _1282687;
float _1282686;
_1282686 = _1282678 + _1282685;
int _1282676;
_1282676 = _1282675 + gid_x_1282525;
float _1282690;
_1282690 = _1282688 + _1282689;
float* idx_1282677;
idx_1282677 = _1026669_1282497 + _1282676;
float _1282692;
_1282692 = _1282690 + _1282691;
float _1282694;
_1282694 = _1282692 + _1282693;
float val_1282695;
val_1282695 = _1282686 + _1282694;
*idx_1282677 = val_1282695;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1004284(struct_Img_220118 _1004287_1268319, struct_Img_220118 _1004288_1268320, float* _1004289_1268321, struct_Img_220118 _1004290_1268322, float* _1004291_1268323, float* _1004292_1268324) {
int _1268327;
int p_1268327;
int _1268330;
int p_1268330;
int _1268333;
int p_1268333;
int _1268336;
int p_1268336;
int _1268339;
int p_1268339;
int _1268342;
int p_1268342;
int _1268345;
int p_1268345;
struct_BoundaryMode_220129 bh_lower_1268352;
struct_BoundaryMode_220129 pbh_lower_1268352;
struct_BoundaryMode_220129 bh_lower_1268359;
struct_BoundaryMode_220129 pbh_lower_1268359;
float _1268376;
float p_1268376;
float _1268379;
float p_1268379;
struct_BoundaryMode_220129 bh_lower_1268383;
struct_BoundaryMode_220129 pbh_lower_1268383;
struct_BoundaryMode_220129 bh_lower_1268389;
struct_BoundaryMode_220129 pbh_lower_1268389;
float _1268405;
float p_1268405;
float _1268408;
float p_1268408;
struct_BoundaryMode_220129 bh_lower_1268414;
struct_BoundaryMode_220129 pbh_lower_1268414;
struct_BoundaryMode_220129 bh_lower_1268418;
struct_BoundaryMode_220129 pbh_lower_1268418;
float _1268434;
float p_1268434;
float _1268437;
float p_1268437;
struct_BoundaryMode_220129 bh_lower_1268443;
struct_BoundaryMode_220129 pbh_lower_1268443;
struct_BoundaryMode_220129 bh_lower_1268447;
struct_BoundaryMode_220129 pbh_lower_1268447;
float _1268463;
float p_1268463;
float _1268466;
float p_1268466;
struct_BoundaryMode_220129 bh_lower_1268470;
struct_BoundaryMode_220129 pbh_lower_1268470;
struct_BoundaryMode_220129 bh_lower_1268476;
struct_BoundaryMode_220129 pbh_lower_1268476;
float _1268492;
float p_1268492;
float _1268495;
float p_1268495;
_1268327 = threadIdx_x();
p_1268327 = _1268327;
l1268325: ;
_1268327 = p_1268327;
_1268330 = blockDim_x();
p_1268330 = _1268330;
l1268328: ;
_1268330 = p_1268330;
_1268333 = blockIdx_x();
p_1268333 = _1268333;
l1268331: ;
_1268333 = p_1268333;
_1268336 = threadIdx_y();
p_1268336 = _1268336;
l1268334: ;
_1268336 = p_1268336;
_1268339 = blockDim_y();
p_1268339 = _1268339;
l1268337: ;
_1268339 = p_1268339;
_1268342 = blockIdx_y();
p_1268342 = _1268342;
l1268340: ;
_1268342 = p_1268342;
_1268345 = blockDim_y();
p_1268345 = _1268345;
l1268343: ;
_1268345 = p_1268345;
int _1268346;
_1268346 = _1268330 * _1268333;
int gid_x_1268347;
gid_x_1268347 = _1268327 + _1268346;
union variant_220130 _1268532;
_1268532.qs32 = gid_x_1268347;
bool _1268348;
_1268348 = gid_x_1268347 < 0;
struct_BoundaryMode_220129 _1268533;
_1268533.e0 = 0;
_1268533.e1 = _1268532;
if (_1268348) goto l1268349; else goto l1268586;
l1268586: ;
pbh_lower_1268352 = _1268533;
goto l1268350;
l1268349: ;
union variant_220130 _1265919_9762;
_1265919_9762.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9764;
_1265920_9764.e0 = 1;
_1265920_9764.e1 = _1265919_9762;
pbh_lower_1268352 = _1265920_9764;
goto l1268350;
l1268350: ;
bh_lower_1268352 = pbh_lower_1268352;
int _1268353;
_1268353 = _1268339 * _1268342;
int gid_y_1268354;
gid_y_1268354 = _1268336 + _1268353;
bool _1268355;
_1268355 = gid_y_1268354 < 0;
union variant_220130 _1268544;
_1268544.qs32 = gid_y_1268354;
struct_BoundaryMode_220129 _1268545;
_1268545.e0 = 0;
_1268545.e1 = _1268544;
if (_1268355) goto l1268356; else goto l1268585;
l1268585: ;
pbh_lower_1268359 = _1268545;
goto l1268357;
l1268356: ;
union variant_220130 _1265919_9772;
_1265919_9772.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9774;
_1265920_9774.e0 = 1;
_1265920_9774.e1 = _1265919_9772;
pbh_lower_1268359 = _1265920_9774;
goto l1268357;
l1268357: ;
bh_lower_1268359 = pbh_lower_1268359;
int _1268368;
_1268368 = _1004288_1268320.e3;
union variant_220130 _1268366;
_1268366 = bh_lower_1268359.e1;
union variant_220130 _1268370;
_1268370 = bh_lower_1268352.e1;
unsigned int _1268360;
_1268360 = bh_lower_1268352.e0;
unsigned int _1268362;
_1268362 = bh_lower_1268359.e0;
bool _1268361;
_1268361 = _1268360 == 0;
bool _1268363;
_1268363 = _1268362 == 0;
bool _1268364;
_1268364 = _1268361 & _1268363;
if (_1268364) goto l1268365; else goto l1268576;
l1268576: ;
bool _1268577;
_1268577 = _1268360 == 1;
if (_1268577) goto l1268578; else goto l1268580;
l1268580: ;
bool _1268581;
_1268581 = _1268362 == 1;
if (_1268581) goto l1268582; else goto l1268584;
l1268584: ;
// bottom: float r4_1265918_9787;
// bottom: p_1268379 = r4_1265918_9787;
goto l1268377;
l1268582: ;
float c_1268583;
c_1268583 = _1268366.pf32;
p_1268379 = c_1268583;
goto l1268377;
l1268578: ;
float c_1268579;
c_1268579 = _1268370.pf32;
p_1268379 = c_1268579;
goto l1268377;
l1268365: ;
int x_1268371;
x_1268371 = _1268370.qs32;
int y_1268367;
y_1268367 = _1268366.qs32;
int _1268369;
_1268369 = y_1268367 * _1268368;
int _1268372;
_1268372 = _1268369 + x_1268371;
float* idx_1268373;
idx_1268373 = _1004289_1268321 + _1268372;
_1268376 = __ldg(idx_1268373);
p_1268376 = _1268376;
l1268374: ;
_1268376 = p_1268376;
p_1268379 = _1268376;
goto l1268377;
l1268377: ;
_1268379 = p_1268379;
int _1268501;
_1268501 = _1004290_1268322.e3;
int _1268502;
_1268502 = gid_y_1268354 * _1268501;
int _1268503;
_1268503 = _1268502 + gid_x_1268347;
float* idx_1268504;
idx_1268504 = _1004292_1268324 + _1268503;
float _1268505;
_1268505 = *idx_1268504;
if (_1268348) goto l1268380; else goto l1268575;
l1268575: ;
pbh_lower_1268383 = _1268533;
goto l1268381;
l1268380: ;
union variant_220130 _1265919_9789;
_1265919_9789.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9791;
_1265920_9791.e0 = 1;
_1265920_9791.e1 = _1265919_9789;
pbh_lower_1268383 = _1265920_9791;
goto l1268381;
l1268381: ;
bh_lower_1268383 = pbh_lower_1268383;
int _1268384;
_1268384 = -1 + gid_y_1268354;
bool _1268385;
_1268385 = _1268384 < 0;
if (_1268385) goto l1268386; else goto l1268571;
l1268571: ;
union variant_220130 _1268572;
_1268572.qs32 = _1268384;
struct_BoundaryMode_220129 _1268573;
_1268573.e0 = 0;
_1268573.e1 = _1268572;
pbh_lower_1268389 = _1268573;
goto l1268387;
l1268386: ;
union variant_220130 _1265919_9800;
_1265919_9800.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9802;
_1265920_9802.e0 = 1;
_1265920_9802.e1 = _1265919_9800;
pbh_lower_1268389 = _1265920_9802;
goto l1268387;
l1268387: ;
bh_lower_1268389 = pbh_lower_1268389;
union variant_220130 _1268396;
_1268396 = bh_lower_1268389.e1;
union variant_220130 _1268399;
_1268399 = bh_lower_1268383.e1;
unsigned int _1268392;
_1268392 = bh_lower_1268389.e0;
unsigned int _1268390;
_1268390 = bh_lower_1268383.e0;
bool _1268393;
_1268393 = _1268392 == 0;
bool _1268391;
_1268391 = _1268390 == 0;
bool _1268394;
_1268394 = _1268391 & _1268393;
if (_1268394) goto l1268395; else goto l1268562;
l1268562: ;
bool _1268563;
_1268563 = _1268390 == 1;
if (_1268563) goto l1268564; else goto l1268566;
l1268566: ;
bool _1268567;
_1268567 = _1268392 == 1;
if (_1268567) goto l1268568; else goto l1268570;
l1268570: ;
// bottom: float r4_1265918_9814;
// bottom: p_1268408 = r4_1265918_9814;
goto l1268406;
l1268568: ;
float c_1268569;
c_1268569 = _1268396.pf32;
p_1268408 = c_1268569;
goto l1268406;
l1268564: ;
float c_1268565;
c_1268565 = _1268399.pf32;
p_1268408 = c_1268565;
goto l1268406;
l1268395: ;
int y_1268397;
y_1268397 = _1268396.qs32;
int _1268398;
_1268398 = y_1268397 * _1268368;
int x_1268400;
x_1268400 = _1268399.qs32;
int _1268401;
_1268401 = _1268398 + x_1268400;
float* idx_1268402;
idx_1268402 = _1004289_1268321 + _1268401;
_1268405 = __ldg(idx_1268402);
p_1268405 = _1268405;
l1268403: ;
_1268405 = p_1268405;
p_1268408 = _1268405;
goto l1268406;
l1268406: ;
_1268408 = p_1268408;
int _1268409;
_1268409 = -1 + gid_x_1268347;
bool _1268410;
_1268410 = _1268409 < 0;
if (_1268410) goto l1268411; else goto l1268559;
l1268559: ;
union variant_220130 _1268560;
_1268560.qs32 = _1268409;
struct_BoundaryMode_220129 _1268561;
_1268561.e0 = 0;
_1268561.e1 = _1268560;
pbh_lower_1268414 = _1268561;
goto l1268412;
l1268411: ;
union variant_220130 _1265919_9820;
_1265919_9820.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9822;
_1265920_9822.e0 = 1;
_1265920_9822.e1 = _1265919_9820;
pbh_lower_1268414 = _1265920_9822;
goto l1268412;
l1268412: ;
bh_lower_1268414 = pbh_lower_1268414;
if (_1268355) goto l1268415; else goto l1268558;
l1268558: ;
pbh_lower_1268418 = _1268545;
goto l1268416;
l1268415: ;
union variant_220130 _1265919_9826;
_1265919_9826.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9828;
_1265920_9828.e0 = 1;
_1265920_9828.e1 = _1265919_9826;
pbh_lower_1268418 = _1265920_9828;
goto l1268416;
l1268416: ;
bh_lower_1268418 = pbh_lower_1268418;
unsigned int _1268419;
_1268419 = bh_lower_1268414.e0;
union variant_220130 _1268425;
_1268425 = bh_lower_1268418.e1;
unsigned int _1268421;
_1268421 = bh_lower_1268418.e0;
bool _1268422;
_1268422 = _1268421 == 0;
union variant_220130 _1268428;
_1268428 = bh_lower_1268414.e1;
bool _1268420;
_1268420 = _1268419 == 0;
bool _1268423;
_1268423 = _1268420 & _1268422;
if (_1268423) goto l1268424; else goto l1268549;
l1268549: ;
bool _1268550;
_1268550 = _1268419 == 1;
if (_1268550) goto l1268551; else goto l1268553;
l1268553: ;
bool _1268554;
_1268554 = _1268421 == 1;
if (_1268554) goto l1268555; else goto l1268557;
l1268557: ;
// bottom: float r4_1265918_9840;
// bottom: p_1268437 = r4_1265918_9840;
goto l1268435;
l1268555: ;
float c_1268556;
c_1268556 = _1268425.pf32;
p_1268437 = c_1268556;
goto l1268435;
l1268551: ;
float c_1268552;
c_1268552 = _1268428.pf32;
p_1268437 = c_1268552;
goto l1268435;
l1268424: ;
int y_1268426;
y_1268426 = _1268425.qs32;
int x_1268429;
x_1268429 = _1268428.qs32;
int _1268427;
_1268427 = y_1268426 * _1268368;
int _1268430;
_1268430 = _1268427 + x_1268429;
float* idx_1268431;
idx_1268431 = _1004289_1268321 + _1268430;
_1268434 = __ldg(idx_1268431);
p_1268434 = _1268434;
l1268432: ;
_1268434 = p_1268434;
p_1268437 = _1268434;
goto l1268435;
l1268435: ;
_1268437 = p_1268437;
int _1268438;
_1268438 = 1 + gid_x_1268347;
bool _1268439;
_1268439 = _1268438 < 0;
if (_1268439) goto l1268440; else goto l1268546;
l1268546: ;
union variant_220130 _1268547;
_1268547.qs32 = _1268438;
struct_BoundaryMode_220129 _1268548;
_1268548.e0 = 0;
_1268548.e1 = _1268547;
pbh_lower_1268443 = _1268548;
goto l1268441;
l1268440: ;
union variant_220130 _1265919_9846;
_1265919_9846.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9848;
_1265920_9848.e0 = 1;
_1265920_9848.e1 = _1265919_9846;
pbh_lower_1268443 = _1265920_9848;
goto l1268441;
l1268441: ;
bh_lower_1268443 = pbh_lower_1268443;
if (_1268355) goto l1268444; else goto l1268543;
l1268543: ;
pbh_lower_1268447 = _1268545;
goto l1268445;
l1268444: ;
union variant_220130 _1265919_9852;
_1265919_9852.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9854;
_1265920_9854.e0 = 1;
_1265920_9854.e1 = _1265919_9852;
pbh_lower_1268447 = _1265920_9854;
goto l1268445;
l1268445: ;
bh_lower_1268447 = pbh_lower_1268447;
union variant_220130 _1268457;
_1268457 = bh_lower_1268443.e1;
union variant_220130 _1268454;
_1268454 = bh_lower_1268447.e1;
unsigned int _1268448;
_1268448 = bh_lower_1268443.e0;
bool _1268449;
_1268449 = _1268448 == 0;
unsigned int _1268450;
_1268450 = bh_lower_1268447.e0;
bool _1268451;
_1268451 = _1268450 == 0;
bool _1268452;
_1268452 = _1268449 & _1268451;
if (_1268452) goto l1268453; else goto l1268534;
l1268534: ;
bool _1268535;
_1268535 = _1268448 == 1;
if (_1268535) goto l1268536; else goto l1268538;
l1268538: ;
bool _1268539;
_1268539 = _1268450 == 1;
if (_1268539) goto l1268540; else goto l1268542;
l1268542: ;
// bottom: float r4_1265918_9866;
// bottom: p_1268466 = r4_1265918_9866;
goto l1268464;
l1268540: ;
float c_1268541;
c_1268541 = _1268454.pf32;
p_1268466 = c_1268541;
goto l1268464;
l1268536: ;
float c_1268537;
c_1268537 = _1268457.pf32;
p_1268466 = c_1268537;
goto l1268464;
l1268453: ;
int y_1268455;
y_1268455 = _1268454.qs32;
int x_1268458;
x_1268458 = _1268457.qs32;
int _1268456;
_1268456 = y_1268455 * _1268368;
int _1268459;
_1268459 = _1268456 + x_1268458;
float* idx_1268460;
idx_1268460 = _1004289_1268321 + _1268459;
_1268463 = __ldg(idx_1268460);
p_1268463 = _1268463;
l1268461: ;
_1268463 = p_1268463;
p_1268466 = _1268463;
goto l1268464;
l1268464: ;
_1268466 = p_1268466;
if (_1268348) goto l1268467; else goto l1268531;
l1268531: ;
pbh_lower_1268470 = _1268533;
goto l1268468;
l1268467: ;
union variant_220130 _1265919_9867;
_1265919_9867.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9869;
_1265920_9869.e0 = 1;
_1265920_9869.e1 = _1265919_9867;
pbh_lower_1268470 = _1265920_9869;
goto l1268468;
l1268468: ;
bh_lower_1268470 = pbh_lower_1268470;
int _1268471;
_1268471 = 1 + gid_y_1268354;
bool _1268472;
_1268472 = _1268471 < 0;
if (_1268472) goto l1268473; else goto l1268528;
l1268528: ;
union variant_220130 _1268529;
_1268529.qs32 = _1268471;
struct_BoundaryMode_220129 _1268530;
_1268530.e0 = 0;
_1268530.e1 = _1268529;
pbh_lower_1268476 = _1268530;
goto l1268474;
l1268473: ;
union variant_220130 _1265919_9878;
_1265919_9878.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9880;
_1265920_9880.e0 = 1;
_1265920_9880.e1 = _1265919_9878;
pbh_lower_1268476 = _1265920_9880;
goto l1268474;
l1268474: ;
bh_lower_1268476 = pbh_lower_1268476;
unsigned int _1268479;
_1268479 = bh_lower_1268476.e0;
unsigned int _1268477;
_1268477 = bh_lower_1268470.e0;
union variant_220130 _1268483;
_1268483 = bh_lower_1268476.e1;
union variant_220130 _1268486;
_1268486 = bh_lower_1268470.e1;
bool _1268480;
_1268480 = _1268479 == 0;
bool _1268478;
_1268478 = _1268477 == 0;
bool _1268481;
_1268481 = _1268478 & _1268480;
if (_1268481) goto l1268482; else goto l1268519;
l1268519: ;
bool _1268520;
_1268520 = _1268477 == 1;
if (_1268520) goto l1268521; else goto l1268523;
l1268523: ;
bool _1268524;
_1268524 = _1268479 == 1;
if (_1268524) goto l1268525; else goto l1268527;
l1268527: ;
// bottom: float r4_1265918_9892;
// bottom: p_1268495 = r4_1265918_9892;
goto l1268493;
l1268525: ;
float c_1268526;
c_1268526 = _1268483.pf32;
p_1268495 = c_1268526;
goto l1268493;
l1268521: ;
float c_1268522;
c_1268522 = _1268486.pf32;
p_1268495 = c_1268522;
goto l1268493;
l1268482: ;
int x_1268487;
x_1268487 = _1268486.qs32;
int y_1268484;
y_1268484 = _1268483.qs32;
int _1268485;
_1268485 = y_1268484 * _1268368;
int _1268488;
_1268488 = _1268485 + x_1268487;
float* idx_1268489;
idx_1268489 = _1004289_1268321 + _1268488;
_1268492 = __ldg(idx_1268489);
p_1268492 = _1268492;
l1268490: ;
_1268492 = p_1268492;
p_1268495 = _1268492;
goto l1268493;
l1268493: ;
_1268495 = p_1268495;
int _1268496;
_1268496 = _1004287_1268319.e3;
float _1268509;
_1268509 = 2.500000e-01f * _1268408;
float _1268506;
_1268506 = _1268505;
float _1268511;
_1268511 = 2.500000e-01f * _1268437;
float _1268500;
_1268500 = 2.000000e-01f * _1268379;
int _1268497;
_1268497 = gid_y_1268354 * _1268496;
float _1268513;
_1268513 = 2.500000e-01f * _1268466;
float _1268515;
_1268515 = 2.500000e-01f * _1268495;
float _1268510;
_1268510 = 0.000000e+00f + _1268509;
float _1268507;
_1268507 = 2.000000e-01f * _1268506;
float _1268512;
_1268512 = _1268510 + _1268511;
float _1268508;
_1268508 = _1268500 + _1268507;
int _1268498;
_1268498 = _1268497 + gid_x_1268347;
float _1268514;
_1268514 = _1268512 + _1268513;
float _1268516;
_1268516 = _1268514 + _1268515;
float val_1268517;
val_1268517 = _1268508 + _1268516;
float* idx_1268499;
idx_1268499 = _1004291_1268323 + _1268498;
*idx_1268499 = val_1268517;
return ;
}
__global__ __launch_bounds__ (128 * 1 * 1) void lambda_1023227(float* _1023230_1286240, struct_Img_220118 _1023231_1286241, float* _1023232_1286242, float* _1023233_1286243, struct_Img_220118 _1023234_1286244, struct_Img_220118 _1023235_1286245) {
int _1286248;
int p_1286248;
int _1286251;
int p_1286251;
int _1286254;
int p_1286254;
int _1286257;
int p_1286257;
int _1286260;
int p_1286260;
int _1286263;
int p_1286263;
int _1286266;
int p_1286266;
struct_BoundaryMode_220129 bh_upper_1286277;
struct_BoundaryMode_220129 pbh_upper_1286277;
struct_BoundaryMode_220129 bh_upper_1286288;
struct_BoundaryMode_220129 pbh_upper_1286288;
float _1286305;
float p_1286305;
float _1286308;
float p_1286308;
struct_BoundaryMode_220129 bh_upper_1286312;
struct_BoundaryMode_220129 pbh_upper_1286312;
struct_BoundaryMode_220129 bh_upper_1286318;
struct_BoundaryMode_220129 pbh_upper_1286318;
float _1286334;
float p_1286334;
float _1286337;
float p_1286337;
struct_BoundaryMode_220129 bh_upper_1286343;
struct_BoundaryMode_220129 pbh_upper_1286343;
struct_BoundaryMode_220129 bh_upper_1286347;
struct_BoundaryMode_220129 pbh_upper_1286347;
float _1286363;
float p_1286363;
float _1286366;
float p_1286366;
struct_BoundaryMode_220129 bh_upper_1286372;
struct_BoundaryMode_220129 pbh_upper_1286372;
struct_BoundaryMode_220129 bh_upper_1286376;
struct_BoundaryMode_220129 pbh_upper_1286376;
float _1286392;
float p_1286392;
float _1286395;
float p_1286395;
struct_BoundaryMode_220129 bh_upper_1286399;
struct_BoundaryMode_220129 pbh_upper_1286399;
struct_BoundaryMode_220129 bh_upper_1286405;
struct_BoundaryMode_220129 pbh_upper_1286405;
float _1286421;
float p_1286421;
float _1286424;
float p_1286424;
_1286248 = threadIdx_x();
p_1286248 = _1286248;
l1286246: ;
_1286248 = p_1286248;
_1286251 = blockDim_x();
p_1286251 = _1286251;
l1286249: ;
_1286251 = p_1286251;
_1286254 = blockIdx_x();
p_1286254 = _1286254;
l1286252: ;
_1286254 = p_1286254;
_1286257 = threadIdx_y();
p_1286257 = _1286257;
l1286255: ;
_1286257 = p_1286257;
_1286260 = blockDim_y();
p_1286260 = _1286260;
l1286258: ;
_1286260 = p_1286260;
_1286263 = blockIdx_y();
p_1286263 = _1286263;
l1286261: ;
_1286263 = p_1286263;
_1286266 = blockDim_y();
p_1286266 = _1286266;
l1286264: ;
_1286266 = p_1286266;
int _1286271;
_1286271 = _1286251 * _1286254;
int _1286268;
_1286268 = _1023231_1286241.e1;
int _1286267;
_1286267 = _1023234_1286244.e1;
int _1286269;
_1286269 = _1286268 - 128;
int _1286270;
_1286270 = _1286269 + _1286248;
int gid_x_1286272;
gid_x_1286272 = _1286270 + _1286271;
union variant_220130 _1286461;
_1286461.qs32 = gid_x_1286272;
bool _1286273;
_1286273 = _1286267 <= gid_x_1286272;
struct_BoundaryMode_220129 _1286462;
_1286462.e0 = 0;
_1286462.e1 = _1286461;
if (_1286273) goto l1286274; else goto l1286515;
l1286515: ;
pbh_upper_1286277 = _1286462;
goto l1286275;
l1286274: ;
union variant_220130 _1265919_9907;
_1265919_9907.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9909;
_1265920_9909.e0 = 1;
_1265920_9909.e1 = _1265919_9907;
pbh_upper_1286277 = _1265920_9909;
goto l1286275;
l1286275: ;
bh_upper_1286277 = pbh_upper_1286277;
int _1286279;
_1286279 = _1023231_1286241.e2;
int _1286282;
_1286282 = _1286260 * _1286263;
int _1286278;
_1286278 = _1023234_1286244.e2;
int _1286280;
_1286280 = _1286279 - 1;
int _1286281;
_1286281 = _1286280 + _1286257;
int gid_y_1286283;
gid_y_1286283 = _1286281 + _1286282;
bool _1286284;
_1286284 = _1286278 <= gid_y_1286283;
union variant_220130 _1286473;
_1286473.qs32 = gid_y_1286283;
struct_BoundaryMode_220129 _1286474;
_1286474.e0 = 0;
_1286474.e1 = _1286473;
if (_1286284) goto l1286285; else goto l1286514;
l1286514: ;
pbh_upper_1286288 = _1286474;
goto l1286286;
l1286285: ;
union variant_220130 _1265919_9919;
_1265919_9919.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9921;
_1265920_9921.e0 = 1;
_1265920_9921.e1 = _1265919_9919;
pbh_upper_1286288 = _1265920_9921;
goto l1286286;
l1286286: ;
bh_upper_1286288 = pbh_upper_1286288;
union variant_220130 _1286295;
_1286295 = bh_upper_1286288.e1;
unsigned int _1286291;
_1286291 = bh_upper_1286288.e0;
bool _1286292;
_1286292 = _1286291 == 0;
int _1286297;
_1286297 = _1023234_1286244.e3;
unsigned int _1286289;
_1286289 = bh_upper_1286277.e0;
union variant_220130 _1286299;
_1286299 = bh_upper_1286277.e1;
bool _1286290;
_1286290 = _1286289 == 0;
bool _1286293;
_1286293 = _1286290 & _1286292;
if (_1286293) goto l1286294; else goto l1286505;
l1286505: ;
bool _1286506;
_1286506 = _1286289 == 1;
if (_1286506) goto l1286507; else goto l1286509;
l1286509: ;
bool _1286510;
_1286510 = _1286291 == 1;
if (_1286510) goto l1286511; else goto l1286513;
l1286513: ;
// bottom: float r4_1265918_9934;
// bottom: p_1286308 = r4_1265918_9934;
goto l1286306;
l1286511: ;
float c_1286512;
c_1286512 = _1286295.pf32;
p_1286308 = c_1286512;
goto l1286306;
l1286507: ;
float c_1286508;
c_1286508 = _1286299.pf32;
p_1286308 = c_1286508;
goto l1286306;
l1286294: ;
int x_1286300;
x_1286300 = _1286299.qs32;
int y_1286296;
y_1286296 = _1286295.qs32;
int _1286298;
_1286298 = y_1286296 * _1286297;
int _1286301;
_1286301 = _1286298 + x_1286300;
float* idx_1286302;
idx_1286302 = _1023233_1286243 + _1286301;
_1286305 = __ldg(idx_1286302);
p_1286305 = _1286305;
l1286303: ;
_1286305 = p_1286305;
p_1286308 = _1286305;
goto l1286306;
l1286306: ;
_1286308 = p_1286308;
int _1286430;
_1286430 = _1023235_1286245.e3;
int _1286431;
_1286431 = gid_y_1286283 * _1286430;
int _1286432;
_1286432 = _1286431 + gid_x_1286272;
float* idx_1286433;
idx_1286433 = _1023230_1286240 + _1286432;
float _1286434;
_1286434 = *idx_1286433;
if (_1286273) goto l1286309; else goto l1286504;
l1286504: ;
pbh_upper_1286312 = _1286462;
goto l1286310;
l1286309: ;
union variant_220130 _1265919_9936;
_1265919_9936.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9938;
_1265920_9938.e0 = 1;
_1265920_9938.e1 = _1265919_9936;
pbh_upper_1286312 = _1265920_9938;
goto l1286310;
l1286310: ;
bh_upper_1286312 = pbh_upper_1286312;
int _1286313;
_1286313 = -1 + gid_y_1286283;
bool _1286314;
_1286314 = _1286278 <= _1286313;
if (_1286314) goto l1286315; else goto l1286500;
l1286500: ;
union variant_220130 _1286501;
_1286501.qs32 = _1286313;
struct_BoundaryMode_220129 _1286502;
_1286502.e0 = 0;
_1286502.e1 = _1286501;
pbh_upper_1286318 = _1286502;
goto l1286316;
l1286315: ;
union variant_220130 _1265919_9946;
_1265919_9946.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9948;
_1265920_9948.e0 = 1;
_1265920_9948.e1 = _1265919_9946;
pbh_upper_1286318 = _1265920_9948;
goto l1286316;
l1286316: ;
bh_upper_1286318 = pbh_upper_1286318;
unsigned int _1286321;
_1286321 = bh_upper_1286318.e0;
union variant_220130 _1286328;
_1286328 = bh_upper_1286312.e1;
unsigned int _1286319;
_1286319 = bh_upper_1286312.e0;
union variant_220130 _1286325;
_1286325 = bh_upper_1286318.e1;
bool _1286322;
_1286322 = _1286321 == 0;
bool _1286320;
_1286320 = _1286319 == 0;
bool _1286323;
_1286323 = _1286320 & _1286322;
if (_1286323) goto l1286324; else goto l1286491;
l1286491: ;
bool _1286492;
_1286492 = _1286319 == 1;
if (_1286492) goto l1286493; else goto l1286495;
l1286495: ;
bool _1286496;
_1286496 = _1286321 == 1;
if (_1286496) goto l1286497; else goto l1286499;
l1286499: ;
// bottom: float r4_1265918_9960;
// bottom: p_1286337 = r4_1265918_9960;
goto l1286335;
l1286497: ;
float c_1286498;
c_1286498 = _1286325.pf32;
p_1286337 = c_1286498;
goto l1286335;
l1286493: ;
float c_1286494;
c_1286494 = _1286328.pf32;
p_1286337 = c_1286494;
goto l1286335;
l1286324: ;
int y_1286326;
y_1286326 = _1286325.qs32;
int _1286327;
_1286327 = y_1286326 * _1286297;
int x_1286329;
x_1286329 = _1286328.qs32;
int _1286330;
_1286330 = _1286327 + x_1286329;
float* idx_1286331;
idx_1286331 = _1023233_1286243 + _1286330;
_1286334 = __ldg(idx_1286331);
p_1286334 = _1286334;
l1286332: ;
_1286334 = p_1286334;
p_1286337 = _1286334;
goto l1286335;
l1286335: ;
_1286337 = p_1286337;
int _1286338;
_1286338 = -1 + gid_x_1286272;
bool _1286339;
_1286339 = _1286267 <= _1286338;
if (_1286339) goto l1286340; else goto l1286488;
l1286488: ;
union variant_220130 _1286489;
_1286489.qs32 = _1286338;
struct_BoundaryMode_220129 _1286490;
_1286490.e0 = 0;
_1286490.e1 = _1286489;
pbh_upper_1286343 = _1286490;
goto l1286341;
l1286340: ;
union variant_220130 _1265919_9965;
_1265919_9965.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9967;
_1265920_9967.e0 = 1;
_1265920_9967.e1 = _1265919_9965;
pbh_upper_1286343 = _1265920_9967;
goto l1286341;
l1286341: ;
bh_upper_1286343 = pbh_upper_1286343;
if (_1286284) goto l1286344; else goto l1286487;
l1286487: ;
pbh_upper_1286347 = _1286474;
goto l1286345;
l1286344: ;
union variant_220130 _1265919_9971;
_1265919_9971.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9973;
_1265920_9973.e0 = 1;
_1265920_9973.e1 = _1265919_9971;
pbh_upper_1286347 = _1265920_9973;
goto l1286345;
l1286345: ;
bh_upper_1286347 = pbh_upper_1286347;
unsigned int _1286348;
_1286348 = bh_upper_1286343.e0;
union variant_220130 _1286354;
_1286354 = bh_upper_1286347.e1;
unsigned int _1286350;
_1286350 = bh_upper_1286347.e0;
union variant_220130 _1286357;
_1286357 = bh_upper_1286343.e1;
bool _1286349;
_1286349 = _1286348 == 0;
bool _1286351;
_1286351 = _1286350 == 0;
bool _1286352;
_1286352 = _1286349 & _1286351;
if (_1286352) goto l1286353; else goto l1286478;
l1286478: ;
bool _1286479;
_1286479 = _1286348 == 1;
if (_1286479) goto l1286480; else goto l1286482;
l1286482: ;
bool _1286483;
_1286483 = _1286350 == 1;
if (_1286483) goto l1286484; else goto l1286486;
l1286486: ;
// bottom: float r4_1265918_9985;
// bottom: p_1286366 = r4_1265918_9985;
goto l1286364;
l1286484: ;
float c_1286485;
c_1286485 = _1286354.pf32;
p_1286366 = c_1286485;
goto l1286364;
l1286480: ;
float c_1286481;
c_1286481 = _1286357.pf32;
p_1286366 = c_1286481;
goto l1286364;
l1286353: ;
int x_1286358;
x_1286358 = _1286357.qs32;
int y_1286355;
y_1286355 = _1286354.qs32;
int _1286356;
_1286356 = y_1286355 * _1286297;
int _1286359;
_1286359 = _1286356 + x_1286358;
float* idx_1286360;
idx_1286360 = _1023233_1286243 + _1286359;
_1286363 = __ldg(idx_1286360);
p_1286363 = _1286363;
l1286361: ;
_1286363 = p_1286363;
p_1286366 = _1286363;
goto l1286364;
l1286364: ;
_1286366 = p_1286366;
int _1286367;
_1286367 = 1 + gid_x_1286272;
bool _1286368;
_1286368 = _1286267 <= _1286367;
if (_1286368) goto l1286369; else goto l1286475;
l1286475: ;
union variant_220130 _1286476;
_1286476.qs32 = _1286367;
struct_BoundaryMode_220129 _1286477;
_1286477.e0 = 0;
_1286477.e1 = _1286476;
pbh_upper_1286372 = _1286477;
goto l1286370;
l1286369: ;
union variant_220130 _1265919_9990;
_1265919_9990.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9992;
_1265920_9992.e0 = 1;
_1265920_9992.e1 = _1265919_9990;
pbh_upper_1286372 = _1265920_9992;
goto l1286370;
l1286370: ;
bh_upper_1286372 = pbh_upper_1286372;
if (_1286284) goto l1286373; else goto l1286472;
l1286472: ;
pbh_upper_1286376 = _1286474;
goto l1286374;
l1286373: ;
union variant_220130 _1265919_9996;
_1265919_9996.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_9998;
_1265920_9998.e0 = 1;
_1265920_9998.e1 = _1265919_9996;
pbh_upper_1286376 = _1265920_9998;
goto l1286374;
l1286374: ;
bh_upper_1286376 = pbh_upper_1286376;
unsigned int _1286377;
_1286377 = bh_upper_1286372.e0;
bool _1286378;
_1286378 = _1286377 == 0;
union variant_220130 _1286386;
_1286386 = bh_upper_1286372.e1;
union variant_220130 _1286383;
_1286383 = bh_upper_1286376.e1;
unsigned int _1286379;
_1286379 = bh_upper_1286376.e0;
bool _1286380;
_1286380 = _1286379 == 0;
bool _1286381;
_1286381 = _1286378 & _1286380;
if (_1286381) goto l1286382; else goto l1286463;
l1286463: ;
bool _1286464;
_1286464 = _1286377 == 1;
if (_1286464) goto l1286465; else goto l1286467;
l1286467: ;
bool _1286468;
_1286468 = _1286379 == 1;
if (_1286468) goto l1286469; else goto l1286471;
l1286471: ;
// bottom: float r4_1265918_10010;
// bottom: p_1286395 = r4_1265918_10010;
goto l1286393;
l1286469: ;
float c_1286470;
c_1286470 = _1286383.pf32;
p_1286395 = c_1286470;
goto l1286393;
l1286465: ;
float c_1286466;
c_1286466 = _1286386.pf32;
p_1286395 = c_1286466;
goto l1286393;
l1286382: ;
int y_1286384;
y_1286384 = _1286383.qs32;
int x_1286387;
x_1286387 = _1286386.qs32;
int _1286385;
_1286385 = y_1286384 * _1286297;
int _1286388;
_1286388 = _1286385 + x_1286387;
float* idx_1286389;
idx_1286389 = _1023233_1286243 + _1286388;
_1286392 = __ldg(idx_1286389);
p_1286392 = _1286392;
l1286390: ;
_1286392 = p_1286392;
p_1286395 = _1286392;
goto l1286393;
l1286393: ;
_1286395 = p_1286395;
if (_1286273) goto l1286396; else goto l1286460;
l1286460: ;
pbh_upper_1286399 = _1286462;
goto l1286397;
l1286396: ;
union variant_220130 _1265919_10011;
_1265919_10011.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_10013;
_1265920_10013.e0 = 1;
_1265920_10013.e1 = _1265919_10011;
pbh_upper_1286399 = _1265920_10013;
goto l1286397;
l1286397: ;
bh_upper_1286399 = pbh_upper_1286399;
int _1286400;
_1286400 = 1 + gid_y_1286283;
bool _1286401;
_1286401 = _1286278 <= _1286400;
if (_1286401) goto l1286402; else goto l1286457;
l1286457: ;
union variant_220130 _1286458;
_1286458.qs32 = _1286400;
struct_BoundaryMode_220129 _1286459;
_1286459.e0 = 0;
_1286459.e1 = _1286458;
pbh_upper_1286405 = _1286459;
goto l1286403;
l1286402: ;
union variant_220130 _1265919_10021;
_1265919_10021.pf32 = 0.000000e+00f;
struct_BoundaryMode_220129 _1265920_10023;
_1265920_10023.e0 = 1;
_1265920_10023.e1 = _1265919_10021;
pbh_upper_1286405 = _1265920_10023;
goto l1286403;
l1286403: ;
bh_upper_1286405 = pbh_upper_1286405;
union variant_220130 _1286415;
_1286415 = bh_upper_1286399.e1;
union variant_220130 _1286412;
_1286412 = bh_upper_1286405.e1;
unsigned int _1286406;
_1286406 = bh_upper_1286399.e0;
unsigned int _1286408;
_1286408 = bh_upper_1286405.e0;
bool _1286407;
_1286407 = _1286406 == 0;
bool _1286409;
_1286409 = _1286408 == 0;
bool _1286410;
_1286410 = _1286407 & _1286409;
if (_1286410) goto l1286411; else goto l1286448;
l1286448: ;
bool _1286449;
_1286449 = _1286406 == 1;
if (_1286449) goto l1286450; else goto l1286452;
l1286452: ;
bool _1286453;
_1286453 = _1286408 == 1;
if (_1286453) goto l1286454; else goto l1286456;
l1286456: ;
// bottom: float r4_1265918_10035;
// bottom: p_1286424 = r4_1265918_10035;
goto l1286422;
l1286454: ;
float c_1286455;
c_1286455 = _1286412.pf32;
p_1286424 = c_1286455;
goto l1286422;
l1286450: ;
float c_1286451;
c_1286451 = _1286415.pf32;
p_1286424 = c_1286451;
goto l1286422;
l1286411: ;
int x_1286416;
x_1286416 = _1286415.qs32;
int y_1286413;
y_1286413 = _1286412.qs32;
int _1286414;
_1286414 = y_1286413 * _1286297;
int _1286417;
_1286417 = _1286414 + x_1286416;
float* idx_1286418;
idx_1286418 = _1023233_1286243 + _1286417;
_1286421 = __ldg(idx_1286418);
p_1286421 = _1286421;
l1286419: ;
_1286421 = p_1286421;
p_1286424 = _1286421;
goto l1286422;
l1286422: ;
_1286424 = p_1286424;
float _1286438;
_1286438 = 2.500000e-01f * _1286337;
float _1286435;
_1286435 = _1286434;
int _1286425;
_1286425 = _1023231_1286241.e3;
float _1286440;
_1286440 = 2.500000e-01f * _1286366;
float _1286442;
_1286442 = 2.500000e-01f * _1286395;
float _1286444;
_1286444 = 2.500000e-01f * _1286424;
float _1286439;
_1286439 = 0.000000e+00f + _1286438;
float _1286429;
_1286429 = 2.000000e-01f * _1286308;
float _1286436;
_1286436 = 2.000000e-01f * _1286435;
int _1286426;
_1286426 = gid_y_1286283 * _1286425;
float _1286441;
_1286441 = _1286439 + _1286440;
float _1286443;
_1286443 = _1286441 + _1286442;
float _1286445;
_1286445 = _1286443 + _1286444;
float _1286437;
_1286437 = _1286429 + _1286436;
int _1286427;
_1286427 = _1286426 + gid_x_1286272;
float val_1286446;
val_1286446 = _1286437 + _1286445;
float* idx_1286428;
idx_1286428 = _1023232_1286242 + _1286427;
*idx_1286428 = val_1286446;
return ;
}
} |
2,740 | #include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <chrono>
constexpr double pi = 3.14159265358979323846;
class Node_t { // Turn this into separate vectors, because cache exists
public:
__device__
Node_t(float coordinate, int neighbour0, int neighbour1, float velocity)
: coordinate_(coordinate), neighbour_{neighbour0, neighbour1}, velocity_(velocity), velocity_next_(0.0f) {}
float coordinate_;
int neighbour_[2];
float velocity_;
float velocity_next_;
};
class Edge_t {
public:
__device__
Edge_t(int node0, int node1) : nodes_{node0, node1} {}
int nodes_[2];
};
__global__
void create_nodes(int n, Node_t* nodes) {
const int index = blockIdx.x * blockDim.x + threadIdx.x;
const int stride = blockDim.x * gridDim.x;
for (int i = index; i < n; i += stride) {
float coordinate = i * 1.0f/static_cast<float>(n - 1);
float velocity = sin(i * 2.0f * pi/static_cast<float>(n - 1));
int neighbour0 = (i > 0) ? (i - 1) : i;
int neighbour1 = (i < n - 1) ? (i + 1) : i;
nodes[i] = Node_t(coordinate, neighbour0, neighbour1, velocity);
}
}
__global__
void get_velocity(int n, float* velocity, Node_t* nodes) {
const int index = blockIdx.x * blockDim.x + threadIdx.x;
const int stride = blockDim.x * gridDim.x;
for (int i = index; i < n; i += stride) {
velocity[i] = nodes[i].velocity_;
}
}
__global__
void get_coordinates(int n, float* coordinates, Node_t* nodes) {
const int index = blockIdx.x * blockDim.x + threadIdx.x;
const int stride = blockDim.x * gridDim.x;
for (int i = index; i < n; i += stride) {
coordinates[i + 1] = nodes[i].coordinate_;
}
}
__global__
void timestep(int n, float delta_t, Node_t* nodes) {
const int index = blockIdx.x * blockDim.x + threadIdx.x;
const int stride = blockDim.x * gridDim.x;
for (int i = index; i < n; i += stride) {
float u = nodes[i].velocity_;
float u_L = nodes[nodes[i].neighbour_[0]].velocity_;
float u_R = nodes[nodes[i].neighbour_[1]].velocity_;
float r_L = std::abs(nodes[i].coordinate_ - nodes[nodes[i].neighbour_[0]].coordinate_);
float r_R = std::abs(nodes[i].coordinate_ - nodes[nodes[i].neighbour_[1]].coordinate_);
nodes[i].velocity_next_ = u * (1 - delta_t * ((u_R - u_L - ((u_R + u_L - 2 * u) * (std::pow(r_R, 2) - std::pow(r_L, 2)))/(std::pow(r_R, 2) + std::pow(r_L, 2)))/(r_R + r_L)
/(1 + (r_R - r_L) * (std::pow(r_R, 2) - std::pow(r_L, 2))/((r_R + r_L) * (std::pow(r_R, 2) + std::pow(r_L, 2))))));
}
}
__global__
void update(int n, Node_t* nodes) {
const int index = blockIdx.x * blockDim.x + threadIdx.x;
const int stride = blockDim.x * gridDim.x;
for (int i = index; i < n; i += stride) {
nodes[i].velocity_ = nodes[i].velocity_next_;
}
}
void write_data(int n, float time, float* velocity, float* coordinates) {
std::stringstream ss;
std::ofstream file;
ss << "data/output_t" << time << ".dat";
file.open (ss.str());
file << "TITLE = \"Velocity at t= " << time << "\"" << std::endl;
file << "VARIABLES = \"X\", \"U_x\"" << std::endl;
file << "ZONE T= \"Zone 1\", I= " << n << ", J= 1, DATAPACKING = POINT, SOLUTIONTIME = " << time << std::endl;
for (int i = 0; i < n; ++i) {
file << std::setw(12) << coordinates[i] << " " << std::setw(12) << velocity[i] << std::endl;
}
file.close();
}
int main(void) {
const int N = 1000;
float delta_t = 0.00001f;
float time = 0.0f;
int iter_max = 20000;
int write_interval = 2000;
Node_t* nodes;
// Allocate GPU Memory – accessible from GPU
cudaMalloc(&nodes, (N)*sizeof(Node_t));
// Run kernel on 1000 elements on the GPU, initializing nodes
int blockSize = 256;
int numBlocks = (N + blockSize - 1) / blockSize;
create_nodes<<<numBlocks, blockSize>>>(N, nodes);
float* velocity;
cudaMallocManaged(&velocity, (N)*sizeof(float));
float* coordinates;
cudaMallocManaged(&coordinates, (N)*sizeof(float));
get_coordinates<<<numBlocks, blockSize>>>(N, coordinates, nodes);
// Wait for GPU to finish before accessing on host
get_velocity<<<numBlocks, blockSize>>>(N, velocity, nodes);
cudaDeviceSynchronize();
write_data(N, time, velocity, coordinates);
// Calculations
auto t_start = std::chrono::high_resolution_clock::now();
for (int iter = 1; iter <= iter_max; ++iter) {
time += delta_t;
timestep<<<numBlocks, blockSize>>>(N, delta_t, nodes);
update<<<numBlocks, blockSize>>>(N, nodes);
if (!(iter % write_interval)) {
get_velocity<<<numBlocks, blockSize>>>(N, velocity, nodes);
cudaDeviceSynchronize();
write_data(N, time, velocity, coordinates);
}
}
get_velocity<<<numBlocks, blockSize>>>(N, velocity, nodes);
cudaDeviceSynchronize();
auto t_end = std::chrono::high_resolution_clock::now();
std::cout << iter_max << " iterations done in "
<< std::chrono::duration<double, std::milli>(t_end-t_start).count()/1000.0f
<< "s." << std::endl;
write_data(N, time, velocity, coordinates);
// Free memory
cudaFree(nodes);
cudaFree(velocity);
return 0;
} |
2,741 | #include <stdio.h>
#include <assert.h>
#include <cuda.h>
// zwykła funkcja w C/C++
void incrementArrayOnHost(double *tab, int N)
{
for (int i=0; i < N; i++)
tab[i] += 1.0;
}
// funkcja (tzw. kernel) działająca na GPU
__global__ void incrementArrayOnDevice(double *tab, int N)
{
int idx = blockIdx.x*blockDim.x + threadIdx.x;
if (idx<N)
tab[idx] += 1.0;
}
int main(void)
{
const int N = 10000000;
double *a_h, *b_h; // wskaźniki na pamięć na CPU (host)
double *a_d; // wskaźnik na bufor w GPU (device)
// przydział pamięci na CPU
a_h = new double [N];
b_h = new double [N];
// przydział pamięci na GPU
cudaMalloc((void **) &a_d, sizeof(double)*N);
// inicjalizacja danych na CPU
for (int i=0; i<N; i++)
{
a_h[i] = 1.0/(i + 1.0);
}
// przesłąnie danych na GPU: a_h -> a_d
cudaMemcpy(a_d, a_h, sizeof(double)*N, cudaMemcpyDefault );
// robimy jakieś obliczenia na CPU
incrementArrayOnHost(a_h, N);
// a teraz próbujemy zrobić to samo na GPU
int blockSize = 320;
int nBlocks = N/blockSize + (N%blockSize == 0 ? 0 : 1);
// wywołujemy kernel na GPU
incrementArrayOnDevice <<< nBlocks, blockSize >>> (a_d, N);
// kopiujemy wynik z GPU do CPU
cudaMemcpy(b_h, a_d, sizeof(double)*N, cudaMemcpyDefault);
// sprawdzamy wynik
for (int i=0; i<N; i++)
assert(a_h[i] == b_h[i]);
// sprzątamy
delete [] a_h;
delete [] b_h;
cudaFree(a_d);
printf("Jeżeli widzisz ten napis, to program działa poprawnie\n");
}
|
2,742 | #include <iostream>
class cuComplex
{
private:
float r;
float i;
public:
__device__ cuComplex(float a, float b) : r(a), i(b) { }
__device__ float norm(void)
{
return r*r + i*i;
}
__device__ cuComplex operator*(const cuComplex &a)
{
return cuComplex(r*a.r - i*a.i, i*a.r + r*a.i);
}
__device__ cuComplex operator+(const cuComplex &a)
{
return cuComplex(r+a.r, i+a.i);
}
};
__device__ int k_julia(int DIM, int x, int y)
{
const float scale = 1.5;
float jx = scale * (float)(DIM/2 - x)/(DIM/2);
float jy = scale * (float)(DIM/2 - y)/(DIM/2);
cuComplex c(-0.8, 0.156);
cuComplex a(jx, jy);
int i = 0;
for (i = 0; i < 200; i++)
{
a = a * a + c;
if (a.norm() > 1000)
return 0;
}
return 1;
}
__global__ void d_kernel(int DIM, unsigned char *ptr)
{
int x = threadIdx.x + blockIdx.x * blockDim.x;
int y = threadIdx.y + blockIdx.y * blockDim.y;
int offset = x + y * blockDim.x * gridDim.x;
int julia_value = k_julia(DIM, x, y);
ptr[offset * 3 + 0] = 255 * julia_value;
ptr[offset * 3 + 1] = 0;
ptr[offset * 3 + 2] = 0;
}
void run_dat_kernel(int DIM, unsigned char *host_buffer)
{
unsigned char *dev_buffer;
cudaMalloc((void**)&dev_buffer, 3*DIM*DIM*sizeof(unsigned char));
int N = 16;
dim3 blocks(DIM/N, DIM/N);
dim3 threads(N, N);
d_kernel<<<blocks,threads>>>(DIM, dev_buffer);
cudaMemcpy(host_buffer, dev_buffer, 3*DIM*DIM*sizeof(unsigned char), cudaMemcpyDeviceToHost);
cudaFree(dev_buffer);
}
|
2,743 | namespace Megakernel
{
__device__ volatile int doneCounter = 0;
__device__ volatile int endCounter = 0;
__device__ int maxConcurrentBlocks = 0;
__device__ volatile int maxConcurrentBlockEvalDone = 0;
}
|
2,744 | #include "includes.h"
__global__ void add(double* in, double* out, int offset, int n){
int gid = threadIdx.x + blockIdx.x * blockDim.x;
if(gid >= n) return ;
out[gid] = in[gid];
if(gid >= offset)
out[gid] += in[gid-offset];
} |
2,745 | #include "includes.h"
__global__ void transform(float *points3d_after, float *points3d, float * transformation_matrix)
{
int x = blockIdx.x * TILE_DIM + threadIdx.x;
int y = blockIdx.y * TILE_DIM + threadIdx.y;
int w = gridDim.x * TILE_DIM;
for (int j = 0; j < TILE_DIM; j+= BLOCK_ROWS)
{
int iw = x;
int ih = y + j;
for (int ic = 0; ic < 3; ic ++) {
points3d_after[(ih * w + iw) * 3 + ic] = points3d[(ih * w + iw) * 4 + 0] * transformation_matrix[4 * ic + 0]
+ points3d[(ih * w + iw) * 4 + 1] * transformation_matrix[4 * ic + 1]
+ points3d[(ih * w + iw) * 4 + 2] * transformation_matrix[4 * ic + 2]
+ points3d[(ih * w + iw) * 4 + 3] * transformation_matrix[4 * ic + 3];
}
}
} |
2,746 | #include <cuda.h>
extern "C" void initCUDA(int argc, char *argv[]) {
}
extern "C" void exitCUDA(int argc, char *argv[]) {
} |
2,747 | #include <stdio.h>
#include <stdlib.h>
__global__ void fill_matrix_device(int *m, int width)
{
int tx=blockIdx.x;
int ty=blockIdx.y;
int value=(tx+1)*(ty+1);
m[tx*width+ty] = value;
}
__global__ void matrix_mult_device(int *Ma, int *Mb, int *Mc, int width)
{
int tx = blockIdx.x;
int ty = blockIdx.y;
int posfil = ty*width ,poscol = tx;
for(int i = 0 ; i < width ; ++i)
Mc[poscol+posfil] += Ma[posfil+i]*Mb[poscol+i*width];
}
void fill_matrix_host(int *m, int width)
{
for(int x=0;x<width;++x) {
for(int y=0;y<width;++y) {
int value=(x+1)*(y+1);
m[x*width+y] = value;
}
}
}
int main(void)
{
int width=2;
int size=width*width*sizeof(int);
int *m , *m1 ,*m2,*mhost;
m = (int *)malloc(size);
m1 = (int *)malloc(size);
m2 = (int *)malloc(size);
mhost = (int *)malloc(size);
memset(mhost, 0, size);
fill_matrix_host(m, width);
fill_matrix_host(m1, width);
fill_matrix_host(m2, width);
//hacemos la multiplicación de matrices
for(int i = 0 ; i < width; ++i)
for(int j = 0 ; j < width; ++j)
for(int k =0 ; k < width ; ++k)
mhost[width*i+j] += m1[i*width + k] * m2[j + width*k];
int *dev_m,*dev_m1,*dev_m2,*dev_mresult;
cudaMalloc((void **)&dev_m, size);
cudaMalloc((void **)&dev_m1, size);
cudaMalloc((void **)&dev_m2, size);
cudaMalloc((void **)&dev_mresult, size);
dim3 dimGrid(width, width);
dim3 dimBlock(1, 1);
cudaMemcpy(dev_m1, m1, size, cudaMemcpyHostToDevice);
cudaMemcpy(dev_m2, m2, size, cudaMemcpyHostToDevice);
cudaMemset(dev_mresult,0,size);
fill_matrix_device<<<dimGrid, dimBlock>>>(dev_m, width);
matrix_mult_device<<<dimGrid, dimBlock>>>(dev_m1,dev_m2,dev_mresult, width);
int *mok;
mok = (int *)malloc(size);
cudaMemcpy(mok, dev_m, size, cudaMemcpyDeviceToHost); //Ejercicio 5
cudaMemcpy(m2, dev_mresult, size, cudaMemcpyDeviceToHost); //ahora m2 tiene el resultado del device
int ok=1;
for(int i=0;i<(width*width);++i) {
if(m[i]!=mok[i]) ok=0;
}
fprintf(stdout, "%s\n", ok?"ok":"error"); //printf sobre el ejercicio 5
//comprobar si la multiplicación a sido correcta
ok = 1;
for(int i = 0 ; i < (width*width);++i){
if(m2[i] != mhost[i]){
ok = 0;
break;
}
}
fprintf(stdout, "%s\n", ok?"ok multiplicacion":"error la multiplicacion ha fallado");
free(m);
free(m1);
free(mok);
free(m2);
free(mhost);
cudaFree(dev_m);
cudaFree(dev_m1);
cudaFree(dev_m2);
return 0;
}
|
2,748 | #include <cuda_runtime.h>
#include <stdio.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); \
} \
}
void initialInt(int *ip, int size){
for(int i = 0; i < size; i++){
ip[i] = i;
}
}
void printMatrix(int *C, const int nx, const int ny){
int *ic = C;
printf("\nMatrix: (%d.%d)\n",nx,ny);
for (int iy=0; iy<ny; iy++) {
for (int ix=0; ix<nx; ix++) {
printf("%3d",ic[ix]);
}
ic += nx;
printf("\n");
}
printf("\n");
}
__global__ void printThreadIndex(int *A, const int nx, const int ny){
int ix = threadIdx.x + blockIdx.x * blockDim.x;
int iy = threadIdx.y + blockIdx.y * blockDim.y;
unsigned int idx = iy*nx + ix;
printf("thread_id (%d,%d) block_id (%d,%d) coordinate (%d,%d) "
"global index %2d ival %2d\n", threadIdx.x, threadIdx.y, blockIdx.x,
blockIdx.y, ix, iy, idx, A[idx]);
}
int main(int argc, char **argv){
// set up device
int dev = 0;
cudaDeviceProp deviceProp;
CHECK(cudaGetDeviceProperties(&deviceProp, dev));
printf("Using Device %d: %s\n", dev, deviceProp.name);
CHECK(cudaSetDevice(dev));
// set matrix dimension
int nx = 8;
int ny = 6;
int nxy = nx*ny;
int nBytes = nxy*sizeof(float);
// malloc host memory
int *h_A;
h_A = (int *)malloc(nBytes);
// iniitialize host matrix with integer
initialInt(h_A, nxy);
printMatrix(h_A, nx, ny);
// malloc device memory
int *d_MatA;
cudaMalloc((void **)&d_MatA, nBytes);
// transfer data from host to device
cudaMemcpy(d_MatA, h_A, nBytes, cudaMemcpyHostToDevice);
// set up execution configuration
dim3 block(4, 2);
dim3 grid((nx+block.x-1)/block.x, (ny+block.y-1)/block.y);
// invoke the kernel
printThreadIndex <<< grid, block >>>(d_MatA, nx, ny);
cudaDeviceSynchronize();
// free host and devide memory
cudaFree(d_MatA);
free(h_A);
// reset device
cudaDeviceReset();
return (0);
} |
2,749 | #include "includes.h"
__global__ void squareMatrixMulKernel(int *c, int *a, int *b, int arrayWidth)
{
float sum = 0;
//여기서 threadIdx.x와 y는 행렬의 인덱스와 같다. 예시) 2x2행렬일때 00 01 10 11
for (int i = 0; i < arrayWidth; ++i)
{
float Aelement = a[threadIdx.y * arrayWidth + i];
float Belement = b[i*arrayWidth + threadIdx.x];
sum += Aelement * Belement;
}
c[threadIdx.y * arrayWidth + threadIdx.x] = sum;
} |
2,750 | #include<iostream>
#include<stdlib.h>
__global__ void add(int *a,int *b,int *c)
{
int index=blockIdx.x*blockDim.x+threadIdx.x;
c[index]=a[index]+b[index];
}
void random_ints(int *a,int N)
{
int i;
for(i=0;i<N;i++)
{
a[i]=i;
}
}
#define N 2048
#define THREADS_PER_BLOCK 64
int main(void)
{
int *a,*b,*c;
int *d_a,*d_b,*d_c;
int size=N*sizeof(int);
cudaMalloc((void **)&d_a,size);
cudaMalloc((void **)&d_b,size);
cudaMalloc((void **)&d_c,size);
a=(int *)malloc(size);random_ints(a,N);
b=(int *)malloc(size);random_ints(b,N);
c=(int *)malloc(size);
cudaMemcpy(d_a,a,size,cudaMemcpyHostToDevice);
cudaMemcpy(d_b,b,size,cudaMemcpyHostToDevice);
add<<<N/THREADS_PER_BLOCK,THREADS_PER_BLOCK>>>(d_a,d_b,d_c);
cudaMemcpy(c,d_c,size,cudaMemcpyDeviceToHost);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
int i;
for(i=0;i<N;i++)
{
std::cout<<c[i]<<"\n";
}
return 0;
}
|
2,751 | /* TO DO: Please put your name and date of modification
*
* Author: Brady Chen 5/1/2015
* Modified By:
* <your name> <date>
*
* This is a C code for the computation of a histogram of data from an input text file. The
* text file contains multiple lines of characters. The code generate the frequency histogram
* of characters from the input file.
*/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
/* TO DO: (possible)
*
* Definition of important values:
* MAX_TEXT_LINES -- maximum number of lines for the input file. We initially set to 1000
* If your file contains more than 1000, just change the value
* MAX_LINE_LENGTH -- the length of each line. You change the value
* NUMBER_OF_CHARS -- this the total number of characters used in the input file. We set
* the number to 128 which could include all the standard characters in
* the ASCII code table. If your input file contains more than 128 standard
* characters, please increase the number. For example, you should use 256
* for extended ASCII code.
* TOTAL_SIZE -- this is the total number of characters in the input file.
*
* NOTE: You can change the values of the varibales if necessary but please don't change the variable
* names themselves
*/
#define MAX_TEXT_LINES 4400
#define MAX_LINE_LENGTH 75
#define NUMBER_OF_CHARS 128
#define TOTAL_SIZE (MAX_TEXT_LINES + 10)*(MAX_LINE_LENGTH + 10)
/*
* Declaraion of the arrays of characters
* aTextData -- this is a two dimensional array of char. It contains all the characters
* inputted from the input file. The first index record the lines and the
* second index record the columns in each line. We add 10 on MAX_TEXT_LINES
* and MAX_LINE_LENGTH as safety spaces to crash on off-by-one errors.
*
* NOTE: No need to change this part
*/
char aTextData[MAX_TEXT_LINES + 10][MAX_LINE_LENGTH + 10];
char aFlattenedData[(MAX_TEXT_LINES + 10)*(MAX_LINE_LENGTH + 10)];
/* TO DO:
*
* Declaration of function
* histogram() -- This function takes a two arguments
* aText -- a two dimensional array of char.
* histo -- a one dimensional array which returns the frequency histogram
* of the characrers in the array aText
* NOTE: you need to modify the declararion accordingly based on the changes in the gpu_histogram()
*/
int histogram(char aText[MAX_TEXT_LINES + 10][MAX_LINE_LENGTH + 10], unsigned int histo[NUMBER_OF_CHARS]);
int main(void)
{
/*
* Declaration of variables
* histo -- contains the frequency histogram of the characters
* lineBuffer -- line buffer for reading
* iTextSize -- how large is the array
* iTextUsed -- how many lines contained
*/
unsigned int histo[NUMBER_OF_CHARS];
char lineBuffer[MAX_LINE_LENGTH + 10];
int iTextSize = MAX_TEXT_LINES;
int iTextUsed = 0;
// clean the memory with zeros
memset(aTextData, 0, sizeof(aTextData));
memset(lineBuffer, 0, sizeof(lineBuffer));
/* TO DO: (possible)
* Data read and conversion: The following lines of code do the following
* 1. Find the input file (in this case "input.txt)
* 2. Read the data from the input file and store it in a two dimensional
* array of char
*
* NOTE: Please DO NOT change the following lines of code except for the first
* line, where you are allowed to change the path for the input file
* "input.txt"
*/
char *inputFile = "../input_test.txt"; // you may need to change the path depending on
// where you put the input file
// read input file into the array. use binary mode "rb"
FILE *fin = fopen(inputFile, "rb");
if (!fin) {
printf("cannot read %s\n", inputFile);
return 1;
}
// while not end of file, read another line
while (fgets(lineBuffer, sizeof(lineBuffer)-10, fin) != 0)
{
// check if array has space for another line
if (iTextUsed >= iTextSize)
{
printf("overflow: too many text lines\n");
return 1;
}
// strip CR/LF from line endings so we get pure text
char *psz = strchr(lineBuffer, '\r'); if (psz) *psz = '\0';
psz = strchr(lineBuffer, '\n'); if (psz) *psz = '\0';
// store the line
strncpy(aTextData[iTextUsed], lineBuffer, MAX_LINE_LENGTH);
aTextData[iTextUsed][MAX_LINE_LENGTH - 1] = '\0'; // safety
iTextUsed++;
}
fclose(fin);
/* end of the Data read and conversion */
/* TO DO:
* Function call to compute the frequency histogram of the data
* NOTE: you NEED TO MODIFY this portion.
* 1. declare the blocks and threads
* 2. call the newly implemented kernel function gpu_histogram() .
* Please note that the kernel function DOES NOT take array as argument,
* not to mention two dimensional array in this case.
*/
if (histogram(aTextData, histo) !=0)
return 1;
/* TO DO:
*
* Output of histogram results
* the following is the output of the histogram frequency of characters in
* the order of ASCII code. the array histo[] contains the frequency histogram
* of 128 characters defined in ASCII.
* 1. The decimal values for the letters are
* A to Z -- 65 to 90
* a to z -- 97 to 122
* 2. the following lines of code print the histogram results for a to z.
*
* NOTE: You are required to add code for computing the frequency histogram for
* letters A to Z (including both low case and up case). To do this, you
* could add the frequency histograms for capital letters and low case letters.
* For example, to calcuate the frequency histogram of letter A, you should
* add the frequency histogram of capital A and low case a.
*/
unsigned int histocount = 0; // total character count
printf("histogram frequency of characters a to z: \n");
for (int i = 97; i < 97+26 ; i++) {
histocount += histo[i];
printf("%d ", histo[i]);
}
printf("\n");
printf("histogram frequency of characters in terms of percentiles: \n");
for (int i = 97; i < 97 + 26; i++) {
printf("%.4f ", (float)histo[i]/(float)histocount);
}
/* TO DO: Please add your code here for computing the frequency histogram for all letters
* regardless low or up cases.
*
*/
return 0;
}
/* TO DO:
*
* Implementation of function
* histogram() -- This function takes a two arguments
* aText -- a two dimensional array of char.
* histo -- a one dimensional array which returns the frequency histogram
* of the characrers in the array aText
* NOTE: you need to change the function to kenel function. Here are the changes you need to make
* 1. change the name of the function to gpu_histogram()
* 2. change the arguments to piniters
* gpu_histogram(char * aText, unsigned int * histo)
* 3. re-implement the function
*/
int histogram(char aText[MAX_TEXT_LINES + 10][MAX_LINE_LENGTH + 10], unsigned int histo[NUMBER_OF_CHARS])
{
int i, j;
for (i = 0; i < NUMBER_OF_CHARS; i++)
histo[i] = 0;
for (i = 0; i < MAX_TEXT_LINES+10; i++) {
for (j = 0; j < MAX_LINE_LENGTH + 10; j++) {
histo[(int)(aText[i][j])]++;
}
}
return 0;
}
|
2,752 | #include <cmath>
__global__ void my_copysign(double* v)
{
int i = threadIdx.x;
*v = (i == 0 ? 1 : -1) * (*v);
}
|
2,753 | #include<stdio.h>
#include<time.h>
__global__ void grouptrajectoryKernel(int b, int n, int c, int m,int t, int k, const float * __restrict__ inp, const int * __restrict__ idx, float * __restrict__ out) {
for(int i=blockIdx.x;i<b;i+=gridDim.x){
for(int j=threadIdx.x;j<m;j+=blockDim.x){
for(int u=0;u<k;u++){
int tidx = idx[i*m*k+j*k+u];
for(int v=0;v<t;v++){
for(int w=0;w<c;w++){
out[i*m*k*t*c+j*k*t*c+u*t*c+v*c+w] = inp[i*n*t*c+tidx*t*c+v*c+w];
}
}
}
}
}
}
void grouptrajectoryLauncher(int b, int n, int c, int m,int t, int k, const float *inp, const int *idx, float *out){
//clock_t start,finish;
//double totaltime;
//start=clock();
grouptrajectoryKernel<<<32,512>>>(b,n,c,m,t,k,inp,idx,out);
//finish=clock();
//totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//printf("grouptrajectoryKernel:%f b:%d n:%d c:%d m:%d t:%d k:%d\n",totaltime,b,n,c,m,t,k);
}
__global__ void grouptrajectorygradKernel(int b, int n, int c, int m, int t, int k,const float * __restrict__ out_g, const int * __restrict__ idx, float * __restrict__ inp_g) {
for(int i=blockIdx.x;i<b;i+=gridDim.x){
for(int j=threadIdx.x;j<m;j+=blockDim.x){
for(int u=0;u<k;u++){
int tidx = idx[i*m*k+j*k+u];
for(int v=0;v<t;v++){
for(int w=0;w<c;w++){
atomicAdd(&inp_g[i*n*t*c+tidx*t*c+v*c+w],out_g[i*m*k*t*c+j*k*t*c+u*t*c+v*c+w]);
}
}
}
}
}
}
void grouptrajectorygradLauncher(int b, int n, int c, int m, int t, int k,const float *out_g, const int *idx, float *inp_g){
//clock_t start,finish;
//double totaltime;
//start=clock();
grouptrajectorygradKernel<<<32,512>>>(b,n,c,m,t,k,out_g,idx,inp_g);
//finish=clock();
//totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//printf("grouptrajectorygradKernel:%f b:%d n:%d c:%d m:%d t:%d k:%d\n",totaltime,b,n,c,m,t,k);
}
// input: radius (1), nsample (1), xyz1 (b,n,3), xyz2 (b,m,3)
// output: idx (b,m,nsample), pts_cnt (b,m)
__global__ void queryballtrajectoryKernel(int b, int n, int m,int t, float radius, int kgroup, const float * __restrict__ xyz1, const float * __restrict__ xyz2, int * __restrict__ idx, int * __restrict__ pts_cnt) {
for(int i=blockIdx.x;i<b;i+=gridDim.x){
for(int j=threadIdx.x;j<m;j+=blockDim.x){
int cnt = 0;
for(int u=0;u<n;u++){
if(cnt == kgroup) break;
float t_sum = 0;
for(int v=0;v<t;v++){
int tmp_idx1 = i*n*t*3 + u*t*3 + v*3;
int tmp_idx2 = i*m*t*3 + j*t*3 + v*3;
float x2=xyz2[tmp_idx2+0];
float y2=xyz2[tmp_idx2+1];
float z2=xyz2[tmp_idx2+2];
float x1=xyz1[tmp_idx1+0];
float y1=xyz1[tmp_idx1+1];
float z1=xyz1[tmp_idx1+2];
t_sum+=max(sqrtf((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)+(z2-z1)*(z2-z1)),1e-20f);
}
t_sum/=t;
if(t_sum<radius){
if(cnt==0){
for(int w=0;w<kgroup;w++){
idx[i*m*kgroup+j*kgroup+w] = u;
}
}
idx[i*m*kgroup+j*kgroup+cnt] = u;
cnt+=1;
}
}
pts_cnt[i*m+j] = cnt;
}
}
}
void queryballtrajectoryLauncher(int b, int n, int m,int t, float radius, int kgroup, const float *xyz1, const float *xyz2, int *idx, int *pts_cnt) {
//clock_t start,finish;
//double totaltime;
//start=clock();
queryballtrajectoryKernel<<<32,512>>>(b,n,m,t,radius,kgroup,xyz1,xyz2,idx,pts_cnt);
//finish=clock();
//totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//printf("queryballtrajectoryKernel:%f \n",totaltime);
//cudaDeviceSynchronize();
}
__global__ void selectionsortKernel(int b, int n, int m, int k, const float * __restrict__ dist, int * __restrict__ outi, float * __restrict__ out) {
int batch_index = blockIdx.x;
dist+=m*n*batch_index;
outi+=m*n*batch_index;
out+=m*n*batch_index;
int index = threadIdx.x;
int stride = blockDim.x;
// copy from dist to dist_out
for (int j=index;j<m;j+=stride) {
for (int s=0;s<n;++s) {
out[j*n+s] = dist[j*n+s];
outi[j*n+s] = s;
}
}
float *p_dist;
for (int j=index;j<m;j+=stride) {
p_dist = out+j*n;
// selection sort for the first k elements
for (int s=0;s<k;++s) {
int min=s;
// find the min
for (int t=s+1;t<n;++t) {
if (p_dist[t]<p_dist[min]) {
min = t;
}
}
// swap min-th and i-th element
if (min!=s) {
float tmp = p_dist[min];
p_dist[min] = p_dist[s];
p_dist[s] = tmp;
int tmpi = outi[j*n+min];
outi[j*n+min] = outi[j*n+s];
outi[j*n+s] = tmpi;
}
}
}
}
void selectionsortLauncher(int b, int n, int m, int k, const float *dist, int *outi, float *out) {
//clock_t start,finish;
//double totaltime;
//start=clock();
selectionsortKernel<<<b,256>>>(b,n,m,k,dist,outi,out);
//finish=clock();
//totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//printf("selectionsortKernel:%f \n",totaltime);
//cudaDeviceSynchronize();
}
|
2,754 | #pragma once
#include <vector>
#include <string>
#include <cassert>
#include "Vector3.cuh.cu"
namespace RayTracing
{
class Image
{
private:
int m_width;
int m_height;
cudaResourceDesc m_cudaTextureResourceDesc;
cudaTextureDesc m_cudaTextureDesc;
cudaArray *m_buffer_d = nullptr;
public:
std::vector<Color> buffer;
cudaTextureObject_t cudaTexture;
public:
Image(const std::string &fileName);
template<bool isGPU>
void Init()
{
assert(("Not implemented", false));
}
template<bool isGPU, typename T>
T GetResource()
{
assert(("Not implemented", false));
}
Color GetColor(const float u, const float v) const;
void Deinit();
};
};
|
2,755 | /******************************************************************************
*cr
*cr (C) Copyright 2010 The Board of Trustees of the
*cr University of Illinois
*cr All Rights Reserved
*cr
******************************************************************************/
#include <stdio.h>
const unsigned int BLOCK_SIZE = 512;
__global__ void lcs(int A_grid, int B_grid, int *tab_h, char *A, char *B, int *top, int *left, int A_sz, int B_sz, int loop) {
/********************************************************************
*
* Compute C = A + B
* where A is a (1 * n) vector
* where B is a (1 * n) vector
* where C is a (1 * n) vector
*
********************************************************************/
// INSERT KERNEL CODE HERE
int j = threadIdx.x + blockIdx.x*blockDim.x;
int i = loop - j;
int diag, a, b, m;
/*
------------------------
| diag | a |
-------------------------
| b | tab[i][j] | //we want to calculate tab[i][j]
------------------------
*/
//if (threadIdx.x == 0 ) {
//do some memcpy to shared mem for optimization
//}
if (i < 0 || j < 0 || i>= BLOCK_SIZE || j>=BLOCK_SIZE || (A_grid*BLOCK_SIZE+i) >= A_sz || (B_grid*BLOCK_SIZE+j) >= B_sz) {
return ;
}
//printf("from cuda %d %d\n",i,j);
if (i == 0) {
diag = top[j];
a = top[j+1];
if (j == 0) {
b = left[i+1];
} else {
b = tab_h[i*BLOCK_SIZE + j-1];
}
} else if (j == 0) {
diag = left[i];
b = left[i+1];
//i==0 handled above
a = tab_h[(i-1)*BLOCK_SIZE+ j];
} else {
diag = tab_h[(i-1)*BLOCK_SIZE+ j-1];
a = tab_h[(i-1)*BLOCK_SIZE+ j];
b = tab_h[i*BLOCK_SIZE+ j-1];
}
if (A[A_grid*BLOCK_SIZE+i] == B[B_grid*BLOCK_SIZE+j]) {
tab_h[i*BLOCK_SIZE+ j] = diag +1;
} else {
if (a > b) {
tab_h[i*BLOCK_SIZE+ j]= a;
} else {
tab_h[i*BLOCK_SIZE+ j]= b;
}
}
}
void lcsKernel(int A_grid, int B_grid, int *tab_h, char *A, char *B, int *top, int *left, int A_sz, int B_sz, int loop)
{
// Initialize thread block and kernel grid dimensions ---------------------
//INSERT CODE HERE
int n = (A_sz>B_sz)? A_sz: B_sz;
dim3 DimGrid(1,1,1);//would need to change it to 1,1,1
dim3 DimBlock(BLOCK_SIZE,1,1);
lcs<<<DimGrid, DimBlock>>>(A_grid, B_grid, tab_h, A, B, top, left, A_sz, B_sz, loop);
}
|
2,756 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <cuda.h>
#include <ctime>
#include <time.h>
#include <cuda_runtime.h>
// Kernel CUDA, cada thread trabaja con un elemento de C
__global__ void vecAdd(double *a, double *b, double *c, int n)
{
// Obtencion del thread id global (en el device)
int id = blockIdx.x*blockDim.x+threadIdx.x;
//Comprobacion de no salirse de los limites
if (id < n)
c[id] = a[id] + b[id];
}
int main( int argc, char* argv[] )
{
// Tamaño de los vectores
int n = 100000;
// Vectores de entrada del host
double *h_a;
double *h_b;
// Vector de salida del host
double *h_c;
// vectores de entrada del device
double *d_a;
double *d_b;
// Vector de salida del device
double *d_c;
// Tamaño en bytes de cada vector
size_t bytes = n*sizeof(double);
// Seperando memoria para cada vector del host
h_a = (double*)malloc(bytes);
h_b = (double*)malloc(bytes);
h_c = (double*)malloc(bytes);
// Separando memoria para cada vector del device
//direccion del puntero de la variable, tamaño de memoria a separar
cudaMalloc((void**)&d_a, bytes);
//cudaMalloc(&d_a, bytes);
cudaMalloc((void**)&d_b, bytes);
cudaMalloc((void**)&d_c, bytes);
int i;
// Inicializacion de los vectores de entrada del host
for( i = 0; i < n; i++ ) {
h_a[i] = sin(i)*sin(4*i);
h_b[i] = cos(i)*cos(i);
//printf("%d,%d \n",h_a[i],h_b[i]);
}
// Copia de los vectores del host al device
//puntero destino,puntero fuente,numero de bytes a copiar,tipo de copia
cudaMemcpy( d_a, h_a, bytes, cudaMemcpyHostToDevice);
cudaMemcpy( d_b, h_b, bytes, cudaMemcpyHostToDevice);
//printf("%d,%d \n",d_a[1],d_b[1]);
int blockSize, gridSize;
// numero de threads por bloque
blockSize = 1024;
// Numero de bloques en el grid
gridSize = (int)ceil((float)n/blockSize);
//Toma de tiempo
//unsigned double timer = 0.0;
//cutCreateTimer (& timer ) ;
//cutStartTimer ( timer ) ;
// Ejecucion del kernel
vecAdd<<<gridSize, blockSize>>>(d_a, d_b, d_c, n);
//cudaThreadSynchronize () ;
//cutStopTimer ( timer ) ;
//printf (" CUDA execution time = %f ms\n", cutGetTimerValue ( timer ) ) ;
// Copia del resultado al host
cudaMemcpy( h_c, d_c, bytes, cudaMemcpyDeviceToHost);
//printf("HOLA%d \n",h_c[100000-1]);
// Suma del vector y promedio del mismo
double sum = 0;
for(i=0; i<n; i++){
//printf("%d \n",h_c[i]);
sum += h_c[i];
}
printf("final result: %f\n", sum/(double)n);
// Liberando memoria del device
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
// Liberando memoria del Host
free(h_a);
free(h_b);
free(h_c);
return 0;
}
|
2,757 | //pass
//--blockDim=64 --gridDim=64 --no-inline
#include "cuda.h"
__global__ void foo(int x) {
if (x == 0) {
__syncthreads ();
}
}
|
2,758 | #include <stdio.h>
#define row 4
#define col 5
#define space 4*5*sizeof(int)
#define elements 4*5
//this works until col<=Nthreads. In this case every threads moves only 1 data
__global__ void transpose (int* A, int*B){
int i=threadIdx.x+(blockIdx.x*blockDim.x);
int totlength= blockDim.x*gridDim.x-1;
int factor;
if(blockIdx.x==0) factor=1;
else factor=blockIdx.x;
int j= i*(gridDim.x) %(totlength*factor);
B[j]=A[i];
}
/*x=threadidx, y=blockidx
* while (x<N){ //in case col>Nthreads
M_out(y*N+x)=M_in(x*N+y);
} x+=blockdim.x
*
*/
int main() {
int*A=(int*)malloc(space);
int* dev_A;
int*B=(int*)malloc(space);
int* dev_B;
int i;
for(i=0;i<elements;i++){
A[i]=i;
}
// allocate device copies of A and B
cudaMalloc( (void**)&dev_A, space );
cudaMalloc( (void**)&dev_B, space );
cudaMemcpy( dev_A, A, space, cudaMemcpyHostToDevice ); //send data to device
// launch transpose() kernel
transpose<<< row, col >>>(dev_A, dev_B);
// copy device result back to host copy of c
cudaMemcpy( B, dev_B, space, cudaMemcpyDeviceToHost );
for(i=0;i<elements;i++){
if(i%col==0 && i!=0)printf("\n");
printf("%d ", A[i]);
}
printf("\n");
for(i=0;i<elements;i++){
if(i%row==0 && i!=0)printf("\n");
printf("%d ", B[i]);
}
printf("\n");
free(A); free(B);
cudaFree( dev_A ); cudaFree( dev_B );
return 0;
}
|
2,759 | #include "Tests/Tests.cuh"
int main(int argc, char **argv)
{
//Run tests
if (argc == 2 && argv[1][1] == 't' && argv[1][0] == '-')
{
InitAllTests();
//Tests code here
TreeBuildingTests();
FinalReport();
return EXIT_SUCCESS;
}
return 0;
}
|
2,760 | #include "includes.h"
__global__ void remapAggregateIdxKernel(int size, int *fineAggregateSort, int *aggregateRemapId)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if(idx < size)
{
fineAggregateSort[idx] = aggregateRemapId[fineAggregateSort[idx]];
}
} |
2,761 | #include <iostream>
#define NUM_ELEM 8
#define NUM_THREADS 10
using namespace std;
__global__ void concurrentRW(int *data) {
// NUM_THREADS try to read and write at same location
//data[blockIdx.x] = data[blockIdx.x] + threadIdx.x;
atomicAdd(&data[blockIdx.x], threadIdx.x);
}
int main(int argc, char *argv[]) {
int* data = NULL;
bool errorsDetected = false;
cudaMallocManaged(&data, NUM_ELEM * sizeof(unsigned long long int));
if(data == 0) {
cout << "[HOST] Couldn't allocate memory\n";
return 1;
}
// init all elements to 0
cudaMemset(data, 0, NUM_ELEM);
// launch kernel writes
concurrentRW<<<NUM_ELEM, NUM_THREADS>>>(data);
cudaDeviceSynchronize();
if(cudaSuccess != cudaGetLastError()) {
return 1;
}
for(int i = 0; i < NUM_ELEM; i++) {
cout << i << ". " << data[i] << endl;
if(data[i] != (NUM_THREADS * (NUM_THREADS - 1) / 2)) {
errorsDetected = true;
}
}
if(errorsDetected) {
cout << "Errors detected" << endl;
} else {
cout << "OK" << endl;
}
return 0;
}
|
2,762 | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
__host__ __device__ double3 d3add(double3 a, double3 b) {
/*
* Arguments: two 3d vectors
* Returns: a new vector that is a vector addition of the arguments
*/
double3 ret;
ret.x=a.x+b.x;
ret.y=a.y+b.y;
ret.z=a.z+b.z;
return ret;
}
__host__ __device__ double3 d3sub(double3 a, double3 b) {
/*
* Arguments: two 3d vectors
* Returns: a new vector that is the first vector minus the second vector
*/
double3 ret;
ret.x=a.x-b.x;
ret.y=a.y-b.y;
ret.z=a.z-b.z;
return ret;
}
__host__ __device__ double3 d3multscal(double3 a, double b) {
/*
* Arguments: one 3d vector and a scalar
* Returns: the vector with each component multiplied by the scalar
*/
double3 ret;
ret.x=b*a.x;
ret.y=b*a.y;
ret.z=b*a.z;
return ret;
}
__host__ __device__ double3 d3multscal2(double3 a, double b) {
/*
* Arguments: one 3d vector and a scalar
* Returns: the vector with each component multiplied by the scalar squared
*/
double3 ret;
ret.x=b*b*a.x;
ret.y=b*b*a.y;
ret.z=b*b*a.z;
return ret;
}
__host__ __device__ double3 d3divscal(double3 a, double b) {
/*
* Arguments: one 3d vector and a scalar
* Returns: the vector with each component divided by the scalar
*/
double3 ret;
ret.x=a.x/b;
ret.y=a.y/b;
ret.z=a.z/b;
return ret;
}
__host__ __device__ double d3dotp(double3 a, double3 b) {
/*
* Arguments: two 3d vectors
* Returns: the dot product of the two vectors
*/
return (a.x*b.x)+(a.y*b.y)+(a.z*b.z);
}
__host__ __device__ double3 d3crossp(double3 a, double3 b) {
/*
* Arguments: two 3d vectors
* Returns: the first vector crossed with the second vector
*/
double3 ret;
ret.x=(a.y*b.z)-(a.z*b.y);
ret.y=-(a.x*b.z)+(a.z*b.x);
ret.z=(a.x*b.y)-(a.y*b.x);
return ret;
}
__host__ __device__ double d3mag(double3 a) {
/*
* Arguments: one 3d vector
* Returns: the magnitude of the vector
*/
return sqrt(a.x*a.x+a.y*a.y+a.z*a.z);
}
__host__ __device__ double d3dist(double3 a, double3 b) {
/*
* Arguments: two 3d vectors
* Returns: the magnitude of the first vector minus the second
*/
return d3mag(d3sub(a,b));
}
__host__ __device__ double3 d3unit(double3 a) {
/*
* Arguments: one 3d vector
* Returns: a unit vector pointing in the same direction as the argument vector
*/
return d3divscal(a,d3mag(a));
}
__host__ __device__ double3 d3null() {
/*
* Arguments: none
* Returns: the null vector in 3d
*/
double3 a;
a.x=0.0;
a.y=0.0;
a.z=0.0;
return a;
}
|
2,763 | #include <cuComplex.h>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <complex.h>
#include <math.h>
#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#define h_x 0.01
#define h_y 0.005
#define N 100 //размер расчетной плоскости по X
#define M 400 //размер расчетной плоскости по Y
#define tmax 5 // нужный момент времени
double c(double x, double y);
double v(double t, double x);
void save(const char *prefix, int step, double *a);
int ind (int i, int j) {
return j*(N+1) + i;
}
int main(int argc, char **argv){//int main( int argc, char * argv [] ){
int i;
double t=h_x/2;
double *a = new double[(N+1) * (M+1)];
// U = (double**)malloc((N) * sizeof(double*));
/* // for (i=0;i<N;i++){
U[i]=(double*)malloc((M) * sizeof(double));
}
*/
std::cout << "Bang!" << std::endl;
for (int step = 0; step < 1000; step++){
for (int i = 0; i < N+1; i++)
for (int j = 0; j < M+1; j++){
double x = h_x*i;
double y = h_y*j;
a[ind(i,j)] = x + y + step / 1000.;
}
if (step == (step / 10) * 10 )
save("output", step, a);
}
}
//---------------------------------------------------------------------------//
template<typename T>
static void put(std::fstream &f, const T value) {
union {
char buf[sizeof(T)];
T val;
} helper;
helper.val = value;
std::reverse(helper.buf, helper.buf + sizeof(T));
f.write(helper.buf, sizeof(T));
}
void save(const char *prefix, int step, double *a){
char buffer[50];
sprintf(buffer, "%s.%05d.vtk", prefix, step);
std::fstream f(buffer, std::ios::out);
if (!f){
std::cerr << "Unable to open file " << buffer << std::endl;
return;
}
f << "# vtk DataFile Version 3.0" << std::endl;
f << "U data" << std::endl;
f << "BINARY" << std::endl;
f << "DATASET STRUCTURED_POINTS" << std::endl;
f << "DIMENSIONS " << N+1 << " " << M+1 << " 1" << std::endl;
f << "SPACING " << h_x << " " << h_y << " 1" << std::endl;
f << "ORIGIN 0 0 0" << std::endl;
f << "POINT_DATA " << (N+1) * (M+1) << std::endl;
f << "SCALARS u double" << std::endl;
f << "LOOKUP_TABLE default" << std::endl;
for (int j = 0 ; j < M+1; j++){
for (int i = 0; i < N+1; i++)
put(f, a[ind(i,j)]);
}
}
double v(double t, double x) {
if (5*t<2*M_PI){
return sin(5*t)*exp(-30*(x-0.5)*(x-0.5));
}
else return 0.0;
}
double c(double x, double y) {
if (1.0<y<=1.2){
return 0.8;
}
else if( (0.5<y<=0.8)&(0.2<x<=0.5) ){
return 1.0;
}
else return 0.5;
}
|
2,764 | //xfail:ASSERTION_ERROR
//--blockDim=1024 --gridDim=1 --no-inline
__device__ float multiplyByTwo(float *v, unsigned int tid)
{
return v[tid] * 2.0f;
}
__device__ float divideByTwo(float *v, unsigned int tid)
{
return v[tid] * 0.5f;
}
typedef float(*funcType)(float*, unsigned int);
__global__ void foo(float *v, funcType f, unsigned int size)
{
unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
if (tid < size)
{
float x = (*f)(v, tid);
x += multiplyByTwo(v, tid);
}
}
|
2,765 | /******************************************************************************
*cr
*cr (C) Copyright 2010 The Board of Trustees of the
*cr University of Illinois
*cr All Rights Reserved
*cr
******************************************************************************/
// Define your kernels in this file you may use more than one kernel if you
// need to
// INSERT KERNEL(S) HERE
/******************************************************************************
Setup and invoke your kernel(s) in this function. You may also allocate more
GPU memory if you need to
*******************************************************************************/
void histogram(unsigned int* input, unsigned int* bins, unsigned int num_elements,
unsigned int num_bins) {
// INSERT CODE HERE
}
|
2,766 | #include <stdio.h>
#include <stdlib.h>
/**
* (1) Tempos de execução:
* (a) CUDA: 0m1.626s
* (b) Sequencial: 0m0.324s
* (c) OpenMP: 0m0.314s
* (d) OpenMP - GPU: 0m1.688s
* (e) CUDA - Global: 0m1.723s
*
* (2) Nvprof:
* (a) CUDA:
* (a.1) CUDA memcpy HtoD: 465.46ms
* (a.2) sum_cuda: 21.560ms
* (b) OpenMP - GPU:
* (b.1) CUDA memcpy HtoD: 463.25ms
* (b.2) sum_cuda: 8.1613ms
* (c) CUDA - Global:
* (c.1) CUDA memcpy HtoD: 469.75ms
* (c.2) sum_cuda: 31.788ms
*
* (3) Explicação:
* Os resultados mostram um tempo de execução maior para aqueles códigos
* relacionados a GPU. Isso ocorre devido a complexidade do algoritmo (linear).
* Por ser bastante simples, o custo associado a cópia das informações da memória
* principal para a memória da GPU não compensa.
* Em relação ao uso de memória global ou compartilhada (por cada grupo), no CUDA,
* o que pode-se concluir é que há um prejuízo na utilização da memória global. Isso
* ocorre, porque o acesso a um dado presenta na memória global é mais custoso. A memória
* compartilhada é específica para cada grupo de threads, sendo assim o custo de acesso é, logicamente, menor.
**/
__global__ void sum_cuda(double* a, double *s, int width) {
int t = threadIdx.x;
int b = blockIdx.x*blockDim.x;
// Utilizando memória global
int i;
for (i = blockDim.x/2; i > 0; i /= 2) {
if (t < i && b+t+i < width) {
a[t + b] += a[t + b + i];
}
__syncthreads();
}
if (t == 0) {
s[blockIdx.x] = a[t + b];
}
}
int main()
{
int width = 40000000;
int size = width * sizeof(double);
int block_size = 1024;
int num_blocks = (width-1)/block_size+1;
int s_size = (num_blocks * sizeof(double));
double *a = (double*) malloc (size);
double *s = (double*) malloc (s_size);
for(int i = 0; i < width; i++) {
a[i] = i;
}
double *d_a, *d_s;
// alocação e cópia dos dados
cudaMalloc((void **) &d_a, size);
cudaMemcpy(d_a, a, size, cudaMemcpyHostToDevice);
cudaMalloc((void **) &d_s, s_size);
// definição do número de blocos e threads
dim3 dimGrid(num_blocks,1,1);
dim3 dimBlock(block_size,1,1);
// chamada do kernel
sum_cuda<<<dimGrid,dimBlock>>>(d_a, d_s, width);
// cópia dos resultados para o host
cudaMemcpy(s, d_s, s_size, cudaMemcpyDeviceToHost);
// soma das reduções parciais
for(int i = 1; i < num_blocks; i++)
s[0] += s[i];
printf("\nSum = %f\n",s[0]);
cudaFree(d_a);
cudaFree(d_s);
}
|
2,767 | // ###
// ###
// ### Practical Course: GPU Programming in Computer Vision
// ###
// ###
// ### Technical University Munich, Computer Vision Group
// ### Winter Semester 2013/2014, March 3 - April 4
// ###
// ###
// ### Evgeny Strekalovskiy, Maria Klodt, Jan Stuehmer, Mohamed Souiai
// ###
// ###
// ### Shiv, painkiller047@gmail.com, p053
#include <cuda_runtime.h>
#include <iostream>
using namespace std;
// cuda error checking
#define CUDA_CHECK cuda_check(__FILE__,__LINE__)
void cuda_check(string file, int line)
{
cudaError_t e = cudaGetLastError();
if (e != cudaSuccess)
{
cout << endl << file << ", line " << line << ": " << cudaGetErrorString(e) << " (" << e << ")" << endl;
exit(1);
}
}
// adds elements at a particular index (i) of all input arrays
__device__ float add_elements_at(size_t i, float ** d_in_arrays, int noOfInArrays) {
float sum = 0;
// sum all arrays
for (int arrNo = 0; arrNo < noOfInArrays; arrNo++) {
sum += d_in_arrays[arrNo][i];
}
// return result
return sum;
}
// add arrays - given to be summed arrays as arrays or arrays, out array, size of each array (n), no of arrays to be summed
__global__ void add_arrays(float ** d_in_arrays, float * d_out_array, int n, int noOfInArrays) {
// get thread id
int id = threadIdx.x + blockDim.x * blockIdx.x;
// only threads inside array range compute
if(id < n) {
d_out_array[id] = add_elements_at(id, d_in_arrays, noOfInArrays);
}
}
// GPU allocs, mem copy and calls add arrays kernel
void add_arrays_caller(float * h_AoA[], int n, int noOfInArrays) {
// define block and grid sizes - 1D assumed
// setting a block of 512 threads
dim3 block = dim3(512, 1, 1);
dim3 grid = dim3((n + block.x - 1) / block.x, 1, 1);
// alloc GPU memory for all arrays be added and copy those arrays
float * arraysOnGPU[noOfInArrays];
int bytesPerArray = n * sizeof(float);
for(int i = 0; i < noOfInArrays; i++) {
cudaMalloc((void **) &arraysOnGPU[i], bytesPerArray);
CUDA_CHECK;
cudaMemcpy(arraysOnGPU[i], h_AoA[i], bytesPerArray, cudaMemcpyHostToDevice);
CUDA_CHECK;
}
// GPU memory that contains the above allocation addresses to the in arrays on GPU
float ** d_in_arrays;
cudaMalloc((void ***) &d_in_arrays, sizeof(float *) * noOfInArrays);
CUDA_CHECK;
cudaMemcpy(d_in_arrays, arraysOnGPU, sizeof(float *) * noOfInArrays, cudaMemcpyHostToDevice);
CUDA_CHECK;
// allocate GPU memory for output array
float * d_out_array;
cudaMalloc((void **) &d_out_array, sizeof(float) * bytesPerArray);
CUDA_CHECK;
// call kernel
add_arrays<<<grid, block>>>(d_in_arrays, d_out_array, n, noOfInArrays);
// wait for kernel call to finish
cudaDeviceSynchronize();
CUDA_CHECK;
// copy summed data in output array in GPU back to host
cudaMemcpy(h_AoA[noOfInArrays], d_out_array, bytesPerArray, cudaMemcpyDeviceToHost);
CUDA_CHECK;
// free GPU memory - for both in and out arrays
for(int i = 0; i < noOfInArrays; i++) {
cudaFree(arraysOnGPU[i]);
CUDA_CHECK;
}
cudaFree(d_out_array);
CUDA_CHECK;
}
int main(int argc, char **argv)
{
// alloc and init input arrays on host (CPU)
int n = 20;
int NO_IN_ARRAYS = 2;
float *a = new float[n];
float *b = new float[n];
float *c = new float[n];
for(int i=0; i<n; i++)
{
a[i] = i;
b[i] = (i%5)+1;
c[i] = 0;
}
// CPU computation
for(int i=0; i<n; i++) c[i] = a[i] + b[i];
// print result
cout << "CPU:"<<endl;
for(int i=0; i<n; i++) cout << i << ": " << a[i] << " + " << b[i] << " = " << c[i] << endl;
cout << endl;
// init c
for(int i=0; i<n; i++) c[i] = 0;
// GPU computation
// ###
// ### TODO: Implement the array addition on the GPU, store the result in "c"
// ###
// ### Notes:
// ### 1. Remember to free all GPU arrays after the computation
// ### 2. Always use the macro CUDA_CHECK after each CUDA call, e.g. "cudaMalloc(...); CUDA_CHECK;"
// ### For convenience this macro is defined directly in this file, later we will only include "aux.h"
// following convention
// total arrays including result array
float * h_AoA[] = {a, b, c};
// kernel caller
add_arrays_caller(h_AoA, n, NO_IN_ARRAYS);
// print result
cout << "GPU:"<<endl;
for(int i=0; i<n; i++) cout << i << ": " << a[i] << " + " << b[i] << " = " << c[i] << endl;
cout << endl;
// free CPU arrays
delete[] a;
delete[] b;
delete[] c;
} |
2,768 | #include <stdio.h>
#include <time.h>
__global__ void add(int *a, int *b, int *c);
int main()
{
clock_t t;
int a, b, c;
int *d_a, *d_b, *d_c;
t = clock();
// allocate space for device copies
cudaMalloc(&d_a, sizeof(int));
cudaMalloc(&d_b, sizeof(int));
cudaMalloc(&d_c, sizeof(int));
// setup inputs
a = 1;
b = 2;
// copy inputs to device
cudaMemcpy(d_a, &a, sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_b, &b, sizeof(int), cudaMemcpyHostToDevice);
// Lauch add() kernel on GPU
add<<<1,3>>>(d_a, d_b, d_c);
// copy result back to Host
cudaMemcpy(&c, d_c, sizeof(int), cudaMemcpyDeviceToHost);
t = clock() - t;
printf("result = %d\n time = %e\n", c, (double)t/CLOCKS_PER_SEC);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
}
__global__ void add(int *a, int *b, int *c)
{
*c = *a + *b;
}
|
2,769 | #include <iostream>
#include <chrono>
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <vector>
auto cpuVectorAddition(std::vector<int> A, std::vector<int> B) {
auto start = std::chrono::high_resolution_clock::now();
for(int i = 0;i< A.size();i++) {
A[i] += B[i];
}
auto stop = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stop - start);
std::cout <<"Speed of CPU vector Addition: " << duration.count() <<" micro seconds"<<std::endl;
return duration.count();
}
__global__ void add(int *a, int *b, int*c) {
c[blockIdx.x] = a[blockIdx.x] + b[blockIdx.x];
}
// GPU vector Addition using Pointers
auto gpuVectorAddition(std::vector<int> A, std::vector<int> B) {
size_t n= A.size();
int* h_A = A.data();
int* h_B = B.data();
int *d_a, *d_b, *d_c;
int* h_C = (int *)malloc(sizeof(int)*n);
cudaMalloc((void**)&d_a, sizeof(int)*n);
cudaMalloc((void**)&d_b, sizeof(int)*n);
cudaMalloc((void**)&d_c, sizeof(int)*n);
cudaMemcpy((void *)d_a, h_A, sizeof(int)*n, cudaMemcpyHostToDevice);
cudaMemcpy((void *)d_b, h_B, sizeof(int)*n, cudaMemcpyHostToDevice);
// Timing stuff, record how many seconds it takes for this operation
cudaEvent_t launch_begin, launch_end;
cudaEventCreate(&launch_begin);
cudaEventCreate(&launch_end);
// Warmup
add<<<n,1>>>(d_a, d_b, d_c);// num blocks, num_threads
float total_time = 0;
int num_times = 10;
// Get average of 100 runs
for(int i = 0;i<num_times;i++) {
cudaEventRecord(launch_begin,0);
add<<<n,1>>>(d_a, d_b, d_c);
cudaEventRecord(launch_end,0);
cudaEventSynchronize(launch_end);
float time = 0;
cudaEventElapsedTime(&time, launch_begin, launch_end);
total_time += time;
}
total_time /= num_times;
std::cout <<"Speed of GPU vector Addition: " << total_time <<" micro seconds"<<std::endl;
// Copy memory back and free stuff
cudaMemcpy(h_C, (void **)d_c, sizeof(int)*n, cudaMemcpyDeviceToHost);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
return total_time;
}
void vectorAdditionSpeedTest() {
size_t n = 1000000;
// std::cout<<n<<std::endl;
std::vector<int> A(n,1);
std::vector<int> B(n,-1);
auto timeCpu = cpuVectorAddition(A,B);
auto timeGpu = gpuVectorAddition(A,B);
std::cout<<"Speedup over CPU for addition is: "<< (float)timeCpu/timeGpu <<std::endl;
}
// Observation for CPU vs GPU compute in vector addition, the answer why is as follows:
// 1. CUDA has a start-up overhead. For "small" problems like this one, the startup overhead will outweigh any gains from using the GPU.
template<typename T>
__global__ void mm(T* a, T* b, T* c, T width) {
int x = blockIdx.x; // block id
int y = threadIdx.x; // thread id
T temp = 0;
for(int i = 0;i< width;i++) {
temp += a[x*width + i]*b[i*width+ y];
}
c[x*width + y] = temp;
}
// GPU vector Addition using Pointers
auto gpuMatrixMultiplication(std::vector<int> A, std::vector<int> B, int size, bool print) {
size_t n= A.size();
int* h_A = A.data();
int* h_B = B.data();
int *d_a, *d_b, *d_c;
int* h_C = (int *)malloc(sizeof(int)*n);
cudaMalloc((void**)&d_a, sizeof(int)*n);
cudaMalloc((void**)&d_b, sizeof(int)*n);
cudaMalloc((void**)&d_c, sizeof(int)*n);
cudaMemcpy((void *)d_a, h_A, sizeof(int)*n, cudaMemcpyHostToDevice);
cudaMemcpy((void *)d_b, h_B, sizeof(int)*n, cudaMemcpyHostToDevice);
// Timing stuff, record how many seconds it takes for this operation
cudaEvent_t launch_begin, launch_end;
cudaEventCreate(&launch_begin);
cudaEventCreate(&launch_end);
// Warmup
mm<int><<<size,size>>>(d_a, d_b, d_c,size);// num blocks, num_threads
float total_time = 0;
int num_times = 10;
if(!print){
// Get average of 100 runs
for(int i = 0;i<num_times;i++) {
cudaEventRecord(launch_begin,0);
mm<int><<<size,size>>>(d_a, d_b, d_c, size);
cudaEventRecord(launch_end,0);
cudaEventSynchronize(launch_end);
float time = 0;
cudaEventElapsedTime(&time, launch_begin, launch_end);
total_time += time;
}
}
total_time /= num_times;
// Copy memory back and free stuff
cudaMemcpy(h_C, (void **)d_c, sizeof(int)*n, cudaMemcpyDeviceToHost);
if(print) {
for(int i = 0;i < n;i++) {
std::cout<<h_C[i]<<" ";
}
std::cout<<std::endl;
} else {
std::cout <<"Speed of GPU vector Multiplication: " << total_time <<" micro seconds"<<std::endl;
}
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
return total_time;
}
float mmCpu(std::vector<int> &a, std::vector<int> &b, int n,bool print) {
std::vector<int> c(n*n,0);
auto start = std::chrono::high_resolution_clock::now();
for(int i = 0;i<n;i++) {
for(int j = 0;j< n;j++) {
for(int k = 0;k < n;k++) {
c[i*n + k] += a[i*n + j] * b[j*n + k];
}
}
}
auto stop = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stop - start);
if(print) {
for(auto i: c) {
std::cout<<i<<" ";
}
std::cout<<std::endl;
} else {
std::cout <<"Speed of CPU vector Multiplication: " << duration.count() <<" micro seconds"<<std::endl;
}
return duration.count();
}
void matrixMultiplySpeedTest() {
int size = 100;
std::vector<int> A(size*size);
std::vector<int> B(size*size);
auto gpuSpeed = gpuMatrixMultiplication(A,B,size,false);
auto cpuSpeed = mmCpu(A,B,size,false);
std::cout<<"Speed of GPU over CPU is: "<< cpuSpeed/gpuSpeed<<std::endl;
}
void matrixMultiplyCorrectness() {
int size = 4;
std::vector<int> A = {3,1,2,4,3,1,2,4,3,1,2,4,3,1,2,4};
std::vector<int> B = {3,1,2,4,3,1,2,4,3,1,2,4,3,1,2,4};
gpuMatrixMultiplication(A,B,size,true);
mmCpu(A,B,size,true);
}
// int main() {
// // vectorAdditionSpeedTest();
// matrixMultiplySpeedTest();
// matrixMultiplyCorrectness();
// return 1;
// }
|
2,770 | struct Real3
{
double value[3];
};
template<class T1, class T2>
struct Pair
{
T1 first;
T2 second;
template<class U1, class U2>
__device__ Pair& operator=(const Pair<U1, U2>& other)
{
first = other.first;
second = other.second;
return *this;
}
};
template<class T1, class T2>
inline __device__ Pair<T1&,T2&> pair_tie(T1& first, T2& second)
{
return {first, second};
}
__device__ Pair<Real3, Real3> copy(const Real3& in1, const Real3& in2)
{
return {in1, in2};
}
__global__ void call_min(int* offsets, const Real3* inputs, Real3* outputs)
{
int idx = offsets[threadIdx.x];
// Copy with some bogus offsets
pair_tie(outputs[idx - 1], outputs[idx])
= copy(inputs[idx], inputs[idx + 1]);
}
|
2,771 | #include "includes.h"
__global__ void MatrixMul(float *darray_1, float *darray_2 , float *dres_arr, int n){
// cols and rows definition
int col = threadIdx.x + blockIdx.x * blockDim.x;
int row = threadIdx.y + blockIdx.y * blockDim.y;
// Mat mult operation
for(int i = 0; i<n; i++){
dres_arr[row*n+col]+= darray_1[row*n+i]*darray_2[col+i*n];
// printf("row %i * height %i col %i index %i res %f\n", row, n, col, i, dres_arr[row*n+col]);
}
} |
2,772 | #include "includes.h"
__global__ void increment(char* data, size_t length)
{
size_t global_index = threadIdx.x + blockIdx.x * blockDim.x;
if (global_index < length)
data[global_index]++;
} |
2,773 | #include "includes.h"
__global__ void bcnn_cuda_grad_bias_kernel(float *grad_bias, float *grad_data, int num_channels, int spatial_size)
{
int offset = blockIdx.x * blockDim.x + threadIdx.x;
int channel = blockIdx.y;
int batch_size = blockIdx.z;
if (offset < spatial_size)
grad_bias[channel] += grad_data[(batch_size * num_channels + channel) * spatial_size + offset];
} |
2,774 | #include "includes.h"
__global__ void compactIndicatorToPixelKernel( const unsigned* candidate_pixel_indicator, const unsigned* prefixsum_indicator, unsigned img_cols, ushort2* compacted_pixels ) {
const auto idx = threadIdx.x + blockIdx.x * blockDim.x;
if(candidate_pixel_indicator[idx] > 0) {
const auto offset = prefixsum_indicator[idx] - 1;
const unsigned short x = idx % img_cols;
const unsigned short y = idx / img_cols;
compacted_pixels[offset] = make_ushort2(x, y);
}
} |
2,775 | #include <stdio.h>
int main() {
int nDevices, i;
cudaDeviceProp prop;
cudaGetDeviceCount(&nDevices);
for(i = 0; i<nDevices; i++) {
cudaGetDeviceProperties(&prop, i);
printf("Name: %s, Major: %d, Minor: %d\n", prop.name, prop.major, prop.minor);
printf("Maximum # of Threads Per Block = %d\n", prop.maxThreadsPerBlock);
printf("Maximum # of Threads Per Multiprocessor = %d\n", prop.maxThreadsPerMultiProcessor);
printf("# of Threads Per Warp = %d\n", prop.warpSize);
printf("# of Registers Per Block = %d\n", prop.regsPerBlock);
printf("Size of L2 Cache in bytes = %d\n", prop.l2CacheSize);
printf("Total Global Memory = %d\n", prop.totalGlobalMem);
printf("Total Shared Memory Per Block = %d\n", prop.sharedMemPerBlock);
printf("Total # of Multiprocessors = %d\n", prop.multiProcessorCount);
printf("Clock rate = %d\n", prop.clockRate);
printf("\n");
}
}
|
2,776 | #include "includes.h"
#define KERNEL_RADIUS 31
#define KERNEL_LENGTH (2 * KERNEL_RADIUS + 1)
__constant__ float c_Kernel[ KERNEL_LENGTH ];
__global__ void convolutionZ_63_Kernel( float *d_Dst, float *d_Src, int imageW, int imageH, int imageD, int outofbounds, float outofboundsvalue )
{
// here it is [x][z], we leave out y as it has a size of 1
__shared__ float s_Data[DEPTH_BLOCKDIM_X][(DEPTH_RESULT_STEPS + 2 * DEPTH_HALO_STEPS) * DEPTH_BLOCKDIM_Z + 1];
//Offset to the upper halo edge
const int baseX = blockIdx.x * DEPTH_BLOCKDIM_X + threadIdx.x;
const int baseY = blockIdx.y;
const int baseZ = (blockIdx.z * DEPTH_RESULT_STEPS - DEPTH_HALO_STEPS) * DEPTH_BLOCKDIM_Z + threadIdx.z;
const int firstPixelInLine = (DEPTH_BLOCKDIM_Z * DEPTH_HALO_STEPS - threadIdx.z) * imageW * imageH;
const int lastPixelInLine = (imageD - baseZ - 1) * imageW * imageH;
d_Src += baseZ * imageH * imageW + baseY * imageW + baseX;
d_Dst += baseZ * imageH * imageW + baseY * imageW + baseX;
//Main data
#pragma unroll
for (int i = DEPTH_HALO_STEPS; i < DEPTH_HALO_STEPS + DEPTH_RESULT_STEPS; i++)
{
if ( outofbounds == 0 )
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z] = (imageD - baseZ > i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : 0;
else if ( outofbounds == 1 )
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z] = (imageD - baseZ > i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : outofboundsvalue;
else
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z] = (imageD - baseZ > i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : d_Src[ lastPixelInLine ];
}
//Upper halo
#pragma unroll
for (int i = 0; i < DEPTH_HALO_STEPS; i++)
{
if ( outofbounds == 0 )
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z] = (baseZ >= -i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : 0;
else if ( outofbounds == 1 )
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z] = (baseZ >= -i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : outofboundsvalue;
else
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z] = (baseZ >= -i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : d_Src[ firstPixelInLine ];
}
//Lower halo
#pragma unroll
for (int i = DEPTH_HALO_STEPS + DEPTH_RESULT_STEPS; i < DEPTH_HALO_STEPS + DEPTH_RESULT_STEPS + DEPTH_HALO_STEPS; i++)
{
if ( outofbounds == 0 )
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z]= (imageD - baseZ > i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : 0;
else if ( outofbounds == 1 )
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z]= (imageD - baseZ > i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : outofboundsvalue;
else
s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z]= (imageD - baseZ > i * DEPTH_BLOCKDIM_Z) ? d_Src[i * DEPTH_BLOCKDIM_Z * imageW * imageH] : d_Src[ lastPixelInLine ];
}
//Compute and store results
__syncthreads();
// this pixel is not part of the image and does not need to be convolved
if ( baseX >= imageW )
return;
#pragma unroll
for (int i = DEPTH_HALO_STEPS; i < DEPTH_HALO_STEPS + DEPTH_RESULT_STEPS; i++)
{
if (imageD - baseZ > i * DEPTH_BLOCKDIM_Z)
{
float sum = 0;
#pragma unroll
for (int j = -KERNEL_RADIUS; j <= KERNEL_RADIUS; j++)
{
sum += c_Kernel[KERNEL_RADIUS - j] * s_Data[threadIdx.x][threadIdx.z + i * DEPTH_BLOCKDIM_Z + j];
}
d_Dst[i * DEPTH_BLOCKDIM_Z * imageW * imageH] = sum;
}
}
} |
2,777 | #include "includes.h"
__global__ void hello(char *a, int *b)
{
for (int i=0; i<7; ++i)
{
a[i] += b[i];
}
} |
2,778 | /*#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include<opencv2\imgproc.hpp>
#include <iostream>
#define INF 2e10f
#define SPHERES_C 1300
#define threads 16
#define rnd(x) (x * rand() / RAND_MAX)
#define DIM 1024
struct Spheres {
float x, y, z;
float radius;
float r, g, b;
__device__ float hit(float x_o,float y_o, float *n)
{
float dx = x_o - x;
float dy = y_o - y;
if (dx*dx + dy*dy < radius*radius)
{
float dz = sqrtf(radius*radius-dx*dx-dy*dy);
*n=dz/sqrtf(radius*radius);
return dz + z;
}
return -INF;
}
};
__constant__ Spheres s[SPHERES_C];
__global__ void kernel(unsigned char * d_img)
{
int x = threadIdx.x + blockIdx.x * blockDim.x;
int y = threadIdx.y + blockIdx.y * blockDim.y;
int offset = x + y * blockDim.x * gridDim.x;
float x_o = (x - DIM / 2);
float y_o = (y - DIM / 2);
float r = 0, g = 0, b = 0;
float maxz = -INF;
for (int i = 0; i<SPHERES_C; i++) {
float n;
float t = s[i].hit(x_o, y_o, &n);
if (t > maxz) {
float fscale = n;
r = s[i].r * fscale;
g = s[i].g * fscale;
b = s[i].b * fscale;
maxz = t;
}
}
d_img[offset * 3 + 0] = (int)(b * 255);
d_img[offset * 3 + 1] = (int)(g * 255);
d_img[offset * 3 + 2] = (int)(r * 255);
}
void main()
{
cudaEvent_t start, stop;
float elapsedTime;
unsigned char *d_img;
cv::Mat h_img(DIM,DIM,CV_8UC3,cv::Scalar(0,0,0));
//save data to a buffer on the Host mem
Spheres* temp_s = (Spheres*)malloc(sizeof(Spheres)*SPHERES_C);
for (int i = 0; i < SPHERES_C; i++)
{
temp_s[i].r = rnd(1.0f);
temp_s[i].g = rnd(1.0f);
temp_s[i].b = rnd(1.0f);
temp_s[i].x = rnd(1000.0f) - 500;
temp_s[i].y = rnd(1000.0f) - 500;
temp_s[i].z = rnd(1000.0f) - 500;
temp_s[i].radius = rnd(100.0f) + 20;
}
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start, 0);
//img data set on Device
cudaMalloc(&d_img,(DIM*DIM*h_img.channels()));
cudaMemcpy(d_img,h_img.ptr() ,(DIM*DIM*h_img.channels()),cudaMemcpyHostToDevice);
//Spheres data set on Device
cudaMemcpyToSymbol(s,temp_s, sizeof(Spheres)*SPHERES_C);//send Sphere data to device
free(temp_s);//free memory
dim3 grid((DIM) / threads, (DIM) / threads);
dim3 block(threads, threads);
//kernel Launch
kernel << < grid,block>> >(d_img);
cudaMemcpy(h_img.ptr(), d_img, (DIM*DIM*h_img.channels()), cudaMemcpyDeviceToHost);
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
cudaEventElapsedTime(&elapsedTime,start,stop);
std::cout <<"\nElapsed Time: " <<elapsedTime << std::endl;
cudaEventDestroy(start);
cudaEventDestroy(stop);
cv::imshow("img", h_img);
cv::waitKey();
cv::destroyAllWindows();
cudaFree(d_img);
cudaFree(s);
}
*/ |
2,779 | __global__ void sorted_mean_per_slice(unsigned int* lower_bounds,
unsigned int* upper_bounds,
double* u, // array of particle quantity sorted by slice
unsigned int n_slices,
double* mean_u) // output array of length n_slices with mean values for each slice
/**
Iterate once through all the particles within the
slicing region and calculate simultaneously the mean
value of quantity u for each slice separately.
Assumes the particle array u to be sorted by slices.
The index arrays lower_bounds and upper_bounds
indicate the start and end indices
within the sorted particle arrays for each slice. The respective
slice id is identical to the index within lower_bounds and
upper_bounds.
*/
{
double sum_u;
unsigned int n_macroparticles; // in current slice
for (int sid = blockIdx.x * blockDim.x + threadIdx.x;
sid < n_slices;
sid += blockDim.x * gridDim.x)
{
sum_u = 0;
n_macroparticles = upper_bounds[sid] - lower_bounds[sid];
if (n_macroparticles == 0) {
mean_u[sid] = 0;
} else {
for (int pid = lower_bounds[sid]; pid < upper_bounds[sid]; pid++)
{
sum_u += u[pid];
}
mean_u[sid] = sum_u / n_macroparticles;
}
}
}
__global__ void sorted_std_per_slice(unsigned int* lower_bounds,
unsigned int* upper_bounds,
double* u, // array of particle quantity sorted by slice
unsigned int n_slices,
double* cov_u) // output array of length n_slices with mean values for each slice
/**
Iterate once through all the particles within the
slicing region and calculate simultaneously the
standard deviation of quantity u for each slice separately.
Assumes the particle array u to be sorted by slices.
The index arrays lower_bounds and upper_bounds
indicate the start and end indices
within the sorted particle arrays for each slice. The respective
slice id is identical to the index within lower_bounds and
upper_bounds.
*/
{
double sum_u, mean_u, l_cov_u, du;
unsigned int n_macroparticles; // in current slice
for (int sid = blockIdx.x * blockDim.x + threadIdx.x;
sid < n_slices;
sid += blockDim.x * gridDim.x)
{
sum_u = 0;
n_macroparticles = upper_bounds[sid] - lower_bounds[sid];
if (n_macroparticles <= 1) {
cov_u[sid] = 0;
} else {
for (int pid = lower_bounds[sid]; pid < upper_bounds[sid]; pid++)
{
sum_u += u[pid];
}
mean_u = sum_u / n_macroparticles;
l_cov_u = 0;
for (int pid = lower_bounds[sid]; pid < upper_bounds[sid]; pid++)
{
du = u[pid] - mean_u;
l_cov_u += du * du;
}
cov_u[sid] = sqrt(l_cov_u / (n_macroparticles - 1));
}
}
}
__global__ void sorted_cov_per_slice(unsigned int* lower_bounds,
unsigned int* upper_bounds,
double* u, // array of particle quantity sorted by slice
double* v, // 2nd array of particles
unsigned int n_slices,
double* cov_uv) // output array of length n_slices with mean values for each slice
/**
Iterate once through all the particles within the
slicing region and calculate simultaneously the
covariance of the quantities u,v for each slice separately.
Assumes the particle array u to be sorted by slices.
The index arrays lower_bounds and upper_bounds
indicate the start and end indices
within the sorted particle arrays for each slice. The respective
slice id is identical to the index within lower_bounds and
upper_bounds.
*/
{
for (int sid = blockIdx.x * blockDim.x + threadIdx.x;
sid < n_slices;
sid += blockDim.x * gridDim.x)
{
double sum_u = 0.;
double sum_v = 0.;
unsigned int n_macroparticles = upper_bounds[sid] - lower_bounds[sid];
if (n_macroparticles <= 1) {
cov_uv[sid] = 0;
} else {
for (int pid = lower_bounds[sid]; pid < upper_bounds[sid]; pid++)
{
sum_u += u[pid];
sum_v += v[pid];
}
double mean_u = sum_u / n_macroparticles;
double mean_v = sum_v / n_macroparticles;
double l_cov_u = 0;
for (int pid = lower_bounds[sid]; pid < upper_bounds[sid]; pid++)
{
l_cov_u += (u[pid] - mean_u) * (v[pid] - mean_v);
}
cov_uv[sid] = l_cov_u / (n_macroparticles - 1);
}
}
}
|
2,780 |
//Input file: space delimited
#include <stdio.h>
#include <math.h>
#include <float.h>
#include <cuda.h>
#include <cuda_runtime.h>
//Size of the GPU memory
#define GPU_MEMSIZE_GB 2
//For case in which XSIZE = 1201 and YSIZE = 801
#define GLOBAL_MEM_USE_MB 773
#define MEM_USE_PER_THREAD_B 1280
//MAX_XSIZE_POSSIBLE is the maximum size of x or max number of columns if there is only one row
#define MAX_XSIZE_POSSIBLE floor(((GPU_MEMSIZE_GB * 1000 - GLOBAL_MEM_USE_MB)*1000000)/MEM_USE_PER_THREAD_B)
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))
//#define XSIZE 1201
//#define YSIZE 801
//Always have even number of radius;and divisible by 10
#define RADIUS 100
#define RADSTEP 1
#define ANGLESIZE 36
#define PI 3.14
//#define FILENAME "Annie_coastDEM.txt"
//---------------------------Function declarations--------------------------------------------------------------------------//
__global__ void getMatrix(int* data,float* angle,float* anisotropy,float* azimuth,size_t XSIZE,size_t YSIZE);
int Get_GPU_devices();
static void HandleError( cudaError_t err,const char *file, int line );
//--------------------------------------------------------------------------------------------------------------------------//
//Current Usage:
//Global Memory: 773 MB
__global__ void getMatrix(int* data,float* angle,float* anisotropy,float* azimuth,size_t XSIZE,size_t YSIZE)
{
// SGR I don't see where XSIZE or YSIZE are defined...
//Actual computation
/* int xrad,yrad,xradOrtho1,yradOrtho1,xradOneEighty,yradOneEighty,valueOneEighty;
int valueOrtho1,valueOrtho2,xradOrtho2,yradOrtho2,i,j;
// Hardwired to be at 100 Radius now. This needs to change!
float variance[100];
float orientation[100];
float ortho[100];
float value,sum_value,avg_value;
float sum_valueOrtho,avg_valueOrtho;
// Initializing declared variables
sum_value = 0;
avg_value = 0;
sum_valueOrtho = 0;
avg_valueOrtho = 0;
*/
//for(i=0;i<ANGLESIZE;i++) {
//angle[i] = i * 5 * PI/180;
//printf("%d :: %f\n",i,angle[i]);
// printf("Array Size: %d\n",sizeof(angle)/sizeof(float));
//}
// Thread indices
int x = (blockIdx.x * blockDim.x) + threadIdx.x;
int y = (blockIdx.y * blockDim.y) + threadIdx.y;
//----------------------------------------------------------------------------------------------------------------------------//
if((y>(YSIZE - RADIUS - 1))||(y<(RADIUS))) return;
else if((x>(XSIZE - RADIUS - 1))||(x<(RADIUS))) return;
else
{
//Actual computation
int xrad,yrad,xradOrtho1,yradOrtho1,xradOneEighty,yradOneEighty,valueOneEighty;
int valueOrtho1,valueOrtho2,xradOrtho2,yradOrtho2,i,j;
float variance[RADIUS];
float orientation[RADIUS];
float ortho[RADIUS];
float value,sum_value,avg_value;
float sum_valueOrtho,avg_valueOrtho;
// Initializing declared variables
sum_value = 0;
avg_value = 0;
sum_valueOrtho = 0;
avg_valueOrtho = 0;
// Iniitalize variance, ortho, and orientation arrays with max float value SGR changed i<100 to i<RADIUS
for(i=0;i<RADIUS;i++){
variance[i] = FLT_MAX;
ortho[i] = FLT_MAX;
orientation[i] = FLT_MAX;
}
//Flipped
for(i=0;i<ANGLESIZE;i++) {
//Initializing to 0 so that the sum is zero everytime it starts
sum_value = 0;
sum_valueOrtho = 0;
for(j = 0;j<RADIUS;j+=RADSTEP) {
//Computation for angle of interest
xrad = (int)lrintf(cosf(angle[i]) * (j+1) + x);
yrad = (int)lrintf(sinf(angle[i]) * (j+1) + y);
value = data[y * XSIZE + x] - data[yrad * XSIZE + xrad];
value = value * value;
//One eighty angle computation
xradOneEighty = (int)lrintf(cosf(angle[i]+PI) * (j+1) + x);
yradOneEighty = (int)lrintf(sinf(angle[i]+PI) * (j+1) + y);
valueOneEighty = data[y * XSIZE + x] - data[yradOneEighty * XSIZE + xradOneEighty];
valueOneEighty = valueOneEighty * valueOneEighty;
sum_value = sum_value + value + valueOneEighty;
avg_value = sum_value/(2*(j+1)); //the average variance from scale 1 to scale j
//Computation for values on angle orthogonal to angle of interest
xradOrtho1 = (int)lrintf(cosf(angle[i]+PI/2) * (j+1) + x);
yradOrtho1 = (int)lrintf(sinf(angle[i]+PI/2) * (j+1) + y);
valueOrtho1 = data[y * XSIZE + x] - data[yradOrtho1 * XSIZE + xradOrtho1];
valueOrtho1 = valueOrtho1 * valueOrtho1;
//One eighty ortho angle computation
xradOrtho2 = (int)lrintf(cosf(angle[i]+PI*3/2) * (j+1) + x);
yradOrtho2 = (int)lrintf(sinf(angle[i]+PI*3/2) * (j+1) + y);
valueOrtho2 = data[y * XSIZE + x] - data[yradOrtho2 * XSIZE + xradOrtho2];
valueOrtho2 = valueOrtho2 * valueOrtho2;
sum_valueOrtho = sum_valueOrtho + valueOrtho1 + valueOrtho2;
avg_valueOrtho = sum_valueOrtho/(2*j+1);
//Fail safe to ensure there is no nan or inf when taking anisotropy ratio, later on.
if(avg_value == 0) {
if((avg_valueOrtho < 1) && (avg_valueOrtho > 0)) {
avg_value = avg_valueOrtho;
}
else {
avg_value = 1;
}
}
if(avg_valueOrtho == 0) {
avg_valueOrtho = 1;
}
//Determine if the variance is minimum compared to others at scale j, if so record it and its angle i. If not, pass it
if(avg_value < variance[j]) {
variance[j] = avg_value;
orientation[j] = angle[i];
ortho[j] = avg_valueOrtho;
}
}
}
for(j=0;j<RADIUS;j+=RADSTEP){
anisotropy[y * XSIZE * RADIUS/RADSTEP + x * RADIUS/RADSTEP + j] = ortho[j]/variance[j];
azimuth[y * XSIZE * RADIUS/RADSTEP + x * RADIUS/RADSTEP + j] = orientation[j] * 180/PI;
}
}
}
//--------------------------------------END OF KERNEL-----------------------------------------------------------//
//--------------------------------------Handle Error()-----------------------------------------------------------//
static void HandleError( cudaError_t err,const char *file, int line ) {
if (err != cudaSuccess) {
printf( "%s in %s at line %d\n", cudaGetErrorString( err ),
file, line );
exit( EXIT_FAILURE );
}
}
//--------------------------------------Get_GPU_devices()-----------------------------------------------------------//
int Get_GPU_devices()
{
cudaDeviceProp prop;
int whichDevice,DeviceCount;
HANDLE_ERROR(cudaGetDevice(&whichDevice));
HANDLE_ERROR(cudaGetDeviceProperties(&prop,whichDevice));
if(!prop.deviceOverlap){
printf("Device does not handle overlaps so streams are not possible\n");
return 0;
}
DeviceCount = 0;
HANDLE_ERROR(cudaGetDeviceCount(&DeviceCount));
if(DeviceCount > 0){
//printf("%d Devices Found\n",DeviceCount);
}else{
printf("No devices found or error in reading the number of devices\n");
return 0;
}
for(int i = 0;i<DeviceCount;i++){
cudaDeviceProp properties;
HANDLE_ERROR(cudaGetDeviceProperties(&properties,i));
printf("Device Number: %d\n", i);
printf(" Device name: %s\n", properties.name);
printf(" Device Global Memory size: %zd MB \n",properties.totalGlobalMem/1000000);
printf("\n");
}
return DeviceCount;
}
//-------------------------------------------------------------------------------------------------------------//
int main(int argc,char* argv[])
//int main()
{
if(argc == 1){
printf("Not enough arguments\n");
return 0;
}
#undef RADIUS
#define RADIUS atoi(argv[2])
//Setting the output buffer to 500MB
size_t limit;
cudaDeviceSetLimit(cudaLimitPrintfFifoSize, 500 * 1024 * 1024);
cudaDeviceGetLimit(&limit,cudaLimitPrintfFifoSize);
//File declarations and opening them
FILE *datTxt1,*datTxt,*outputAnisotropy00,*outputAnisotropy09,*outputAnisotropy49,*outputAnisotropy99;
FILE *outputAzimuth00,*outputAzimuth09,*outputAzimuth49,*outputAzimuth99;
FILE * inpCheck;
inpCheck = fopen("inpCheck.txt","w");
if(inpCheck == NULL) {
perror("Cannot open inpcheck.txt file");
return (-1);
}
datTxt1 = fopen(argv[1],"r");
//datTxt1 = fopen("Annie_coastDEM.txt","r");
if(datTxt1 == NULL) {
printf("Cannot open file: %s \nCheck if file exists.\n",argv[1]);
exit(1);
}
outputAnisotropy00 = fopen("outputDataAni_First.txt","w");
outputAnisotropy09 = fopen("outputDataAni_Rad_div_10.txt","w");
outputAnisotropy49 = fopen("outputDataAni_Rad_div_2.txt","w");
outputAnisotropy99 = fopen("outputDataAni_Last.txt","w");
if((outputAnisotropy00 == NULL)||(outputAnisotropy09 == NULL)||(outputAnisotropy49 == NULL)||(outputAnisotropy99 == NULL)) {
perror("Cannot open Anisotropy file");
return (-1);
}
outputAzimuth00 = fopen("outputDataAzi_First.txt","w");
outputAzimuth09 = fopen("outputDataAzi_Rad_div_10.txt","w");
outputAzimuth49 = fopen("outputDataAzi_Rad_div_2.txt","w");
outputAzimuth99 = fopen("outputDataAzi_Last.txt","w");
if((outputAzimuth00 == NULL)||(outputAzimuth09 == NULL)||(outputAzimuth49 == NULL)||(outputAzimuth99 == NULL)) {
perror("Cannot open Azimuth file");
return (-1);
}
//-----------Getting total rows and columns in the data file---------------------------------------------------------------------------------------------------//
size_t XSIZE,YSIZE;
XSIZE = 0;
YSIZE = 0;
int i,j;
//Counting number of columns(x)
char* max_line;
max_line = (char*)malloc(MAX_XSIZE_POSSIBLE);
memset(max_line,'\0',sizeof(max_line));
fgets(max_line,MAX_XSIZE_POSSIBLE,datTxt1)!=NULL;
while(*max_line)if(*max_line++ == ' ')++XSIZE;
XSIZE+=1;
//Counting number of rows(y)
do{
i = fgetc(datTxt1);
if(i == '\n') YSIZE++;
}while(i != EOF);
YSIZE+=1;
fclose(datTxt1);
printf("(XSIZE,YSIZE)::(%zd,%zd)\n",XSIZE,YSIZE);
datTxt = fopen(argv[1],"r");
// datTxt = fopen("Annie_coastDEM.txt","r");
if(datTxt == NULL) {
//printf("Cannot open file: %s\nCheck if file exists\n",argv[1]);
exit(1);
}
//-----------------------Checking if the data size fits the memory of the GPU----------------------------------------------------------------------------------------//
printf("(XSIZE,YSIZE):(%zd,%zd)\n",XSIZE,YSIZE);
//printf("Maximum size possible = %f\nTotal size of current data(XSIZE * YSIZE) = %zd\n",MAX_XSIZE_POSSIBLE,XSIZE * YSIZE);
//(MAX_XSIZE_POSSIBLE - XSIZE*YSIZE >0)? printf("There is enough memory for the computation\n"):printf("There is not enough memory and may result in incorrect results\n");
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------//
int data[YSIZE * XSIZE];
//XSIZE ints in a row which are max of 5 digits
//with a space in the front and the back and space
//between each number
char *startPtr,*endPtr;
char line[XSIZE * 10 +2+(XSIZE-1)];
memset(line, '\0', sizeof(line));
int Value;
i = 0;
j = 0;
//Assuming each number in the data set has a max of 5 characters
char tempVal[5];
memset(tempVal,'\0',sizeof(tempVal));
printf("Working1\n");
while(fgets(line,XSIZE *10 + 2 + (XSIZE-1),datTxt)!=NULL) {
printf("Working2\n");
startPtr = line;
for(i=0;i<XSIZE;i++) {
Value = 0;
memset(tempVal,'\0',sizeof(tempVal));
if(i != (XSIZE - 1)) {
endPtr = strchr(startPtr,' ');
strncpy(tempVal,startPtr,endPtr-startPtr);
Value = atoi(tempVal);
data[j * XSIZE + i] = Value;
fprintf(inpCheck,"%d ",Value);
//printf("(j,i)::(%d,%d)\n",j,i);
endPtr = endPtr + 1;
startPtr = endPtr;
}
else if(i == (XSIZE - 1)){
strcpy(tempVal,startPtr);
Value = atoi(tempVal);
data[j * XSIZE + i] = Value;
fprintf(inpCheck,"%d\n",Value);
//printf("(j,i)::(%d,%d)\n",j,i);
}
}
j++;
}
//------------------------------------Matrix Declarations--------------------------------------------------------------------------------------------------------------//
float angle[ANGLESIZE];
for(int i=0;i<ANGLESIZE;i++) {
angle[i] = i * 5 * PI/180;
//printf("%d :: %f\n",i,angle[i]);
}
float* anisotropy;
anisotropy = (float*)malloc(YSIZE * XSIZE * RADIUS/RADSTEP * sizeof(float));
float *azimuth;
azimuth = (float*)malloc(YSIZE * XSIZE * RADIUS/RADSTEP * sizeof(float));
//anisotropy[0][0][99] = 834;
//--------------------------------------CUDA-------------------------------------------------------------------------------------------------------------------------//
cudaError_t error;
error = cudaSetDevice(Get_GPU_devices() -1);
if(error == cudaSuccess){
printf("success\n");
}else{
printf("unsuccessful\n");
}
int *data_ptr;
float *anisotropy_ptr,*azimuth_ptr,*angle_ptr;
//cudaSetDevice(1);
cudaMalloc((void**)&data_ptr,XSIZE * YSIZE * sizeof(int));
cudaMemcpy(data_ptr,data,XSIZE * YSIZE * sizeof(int),cudaMemcpyHostToDevice);
cudaMalloc((void**)&angle_ptr,ANGLESIZE * sizeof(float));
cudaMemcpy(angle_ptr,angle,ANGLESIZE * sizeof(float),cudaMemcpyHostToDevice);
cudaMalloc((void**)&anisotropy_ptr,YSIZE * XSIZE * RADIUS/RADSTEP * sizeof(float));
cudaMalloc((void**)&azimuth_ptr,YSIZE * XSIZE * RADIUS/RADSTEP * sizeof(float));
printf("Hello1\n");
//dim3 gridSize(3,YSIZE,1);
dim3 gridSize((XSIZE + 512 - 1)/512,YSIZE,1);
dim3 blockSize(512,1,1);
printf("Hello2\n");
getMatrix<<<gridSize,blockSize>>>(data_ptr,angle_ptr,anisotropy_ptr,azimuth_ptr,XSIZE,YSIZE);
error = cudaDeviceSynchronize();
if(error != cudaSuccess)
{
printf("CUDA Device Synchronization Error: %s\n", cudaGetErrorString(error));
// we can't recover from the error -- exit the program
return 0;
}
error = cudaGetLastError();
if(error != cudaSuccess)
{
printf("CUDA Error: %s\n", cudaGetErrorString(error));
// we can't recover from the error -- exit the program
return 0;
}
printf("Hello3\n");
cudaMemcpy(anisotropy,anisotropy_ptr,YSIZE * XSIZE * RADIUS/RADSTEP * sizeof(float),cudaMemcpyDeviceToHost);
cudaMemcpy(azimuth,azimuth_ptr,YSIZE * XSIZE * RADIUS/RADSTEP * sizeof(float),cudaMemcpyDeviceToHost);
printf("Hello4\n");
cudaFree(data_ptr);
cudaFree(angle_ptr);
cudaFree(azimuth_ptr);
cudaFree(anisotropy_ptr);
printf("Hello5\n");
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------//
// Writing to files
for(j=0;j<YSIZE ;j++) {
for(i=0;i<XSIZE ;i++) {
if((j>(YSIZE - RADIUS - 1))||(j<(RADIUS))) continue;
if((i>(XSIZE - RADIUS - 1))||(i<(RADIUS))) continue;
if (i == (XSIZE - RADIUS - 1)) {
fprintf(outputAnisotropy00,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + 0]);
fprintf(outputAzimuth00,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + 0]);
fprintf(outputAnisotropy00,"\n");
fprintf(outputAzimuth00,"\n");
fprintf(outputAnisotropy09,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP +RADIUS/10 -1]);
fprintf(outputAzimuth09,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/10 -1]);
fprintf(outputAnisotropy09,"\n");
fprintf(outputAzimuth09,"\n");
fprintf(outputAnisotropy49,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/2 - 1]);
fprintf(outputAzimuth49,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/2 - 1]);
fprintf(outputAnisotropy49,"\n");
fprintf(outputAzimuth49,"\n");
fprintf(outputAnisotropy99,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS -1]);
fprintf(outputAzimuth99,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS - 1]);
fprintf(outputAnisotropy99,"\n");
fprintf(outputAzimuth99,"\n");
}
else {
fprintf(outputAnisotropy00,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + 0]);
fprintf(outputAzimuth00,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + 0]);
fprintf(outputAnisotropy00,"\t");
fprintf(outputAzimuth00,"\t");
fprintf(outputAnisotropy09,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/10 -1]);
fprintf(outputAzimuth09,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/10 -1]);
fprintf(outputAnisotropy09,"\t");
fprintf(outputAzimuth09,"\t");
fprintf(outputAnisotropy49,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/2 - 1]);
fprintf(outputAzimuth49,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS/2 - 1]);
fprintf(outputAnisotropy49,"\t");
fprintf(outputAzimuth49,"\t");
fprintf(outputAnisotropy99,"%f",anisotropy[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS - 1]);
fprintf(outputAzimuth99,"%f",azimuth[j * XSIZE * RADIUS/RADSTEP + i * RADIUS/RADSTEP + RADIUS - 1]);
fprintf(outputAnisotropy99,"\t");
fprintf(outputAzimuth99,"\t");
}
}
}
fclose(datTxt);
fclose(inpCheck);
fclose(outputAnisotropy00);
fclose(outputAnisotropy09);
fclose(outputAnisotropy49);
fclose(outputAnisotropy99);
fclose(outputAzimuth00);
fclose(outputAzimuth09);
fclose(outputAzimuth49);
fclose(outputAzimuth99);
//free(max_line);
free(anisotropy);
free(azimuth);
size_t free_byte ;
size_t total_byte ;
cudaMemGetInfo( &free_byte, &total_byte );
double free_db = (double)free_byte;
double total_db = (double)total_byte;
double used_db = total_db - free_db;
printf("GPU memory usage: used = %f, free = %f MB, total = %f MB\n",used_db/1024.0/1024.0, free_db/1024.0/1024.0, total_db/1024.0/1024.0);
return 0;
}
|
2,781 | #include <stdio.h>
#include <stdlib.h>
#define N 1024
#define N_THR 512
void fill_ints(int* a, int size){
for(int i =0; i<size; i++)
a[i]=i;
}
__global__ void dotVecs(int *x, int *y, int *r){
__shared__ int s_tmp[N_THR];
int index = threadIdx.x + blockIdx.x * blockDim.x;
int temp = x[index] * y[index];
s_tmp[threadIdx.x] = temp; // store the multiplication to the shared memory
__syncthreads();
// Thread 0 performs the reduction
if(threadIdx.x == 0){
int sum = 0;
for(int i = 0 ; i < N_THR ; i++) sum += s_tmp[i];
*r += sum;
}
}
int main(void){
int *a, *b, *c; // host pointers
int *d_a, *d_b, *d_c; // device pointers
int size = N * sizeof(int);
// Alloc space for device copies of a, b, c
cudaMalloc((void **)&d_a, size);
cudaMalloc((void **)&d_b, size);
cudaMalloc((void **)&d_c, sizeof(int));
a = (int *)malloc(size);
fill_ints(a, N); // Alloc space host, random initialization
b = (int *)malloc(size);
fill_ints(b, N);
c = (int *)malloc(sizeof(int));
// Copy data from host to device memory
// cudaMemcpyHostToDevice is a flag determining copying from host to dev.
cudaMemcpy(d_a, a, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, b, size, cudaMemcpyHostToDevice);
cudaMemset(d_c,0,sizeof(int));
// Launch kernel to add two vector with N threads and 1 block
// Kernel calls are asynchronous
dotVecs<<<2,N_THR>>>(d_a, d_b, d_c);
// Copy results from device to host
// cudaMemcpy blocks CPU until Kernels finish execution
cudaMemcpy(c, d_c, sizeof(int), cudaMemcpyDeviceToHost);
printf("%d\n",*c);
// needs cudaFree to deallocate device pointers
cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
free(a); free(b); free(c);
return 0;
}
|
2,782 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <cuda.h>
int *a, *b; // host data
int *c, *c2; // results
__global__ void vecAdd(int *A, int *B, int *C, int N)
{
int tid = blockIdx.x * blockDim.x + threadIdx.x;
C[tid] = A[tid] + B[tid];
}
void vecAdd_h(int *A1, int *B1, int *C1, int N)
{
for(int i = 0; i < N; i++)
C1[i] = A1[i] * B1[i];
}
int main(int argc, char **argv)
{
// printf("Begin \n");
int v_sizes [4] = {100, 10000, 1000000, 10000000};
for(int j = 0; j < 4; j++) {
int n = v_sizes[j];
int nBytes = n * sizeof(int);
int block_size, block_no;
a = (int *)malloc(nBytes);
b = (int *)malloc(nBytes);
c = (int *)malloc(nBytes);
c2 = (int *)malloc(nBytes);
int *a_d, *b_d, *c_d;
block_size = 100;
block_no = n / block_size;
dim3 dimBlock(block_size, 1, 1);
dim3 dimGrid(block_no, 1, 1);
for(int i = 0; i < n; i++ ) {
a[i] = sin(i) * sin(i);
b[i] = cos(i) * cos(i);
}
// printf("Allocating device memory on device..\n");
cudaMalloc((void **)&a_d, n * sizeof(int));
cudaMalloc((void **)&b_d, n * sizeof(int));
cudaMalloc((void **)&c_d, n * sizeof(int));
// printf("Copying to device..\n");
cudaMemcpy(a_d, a, nBytes, cudaMemcpyHostToDevice);
cudaMemcpy(b_d, b, nBytes, cudaMemcpyHostToDevice);
// printf("Doing GPU Vector add..\n");
clock_t start_d = clock();
vecAdd<<<block_no, block_size>>>(a_d, b_d, c_d, n);
cudaDeviceSynchronize();
clock_t end_d = clock();
// printf("Doing CPU Vector add..\n");
clock_t start_h = clock();
vecAdd_h(a, b, c2, n);
clock_t end_h = clock();
double time_d = (double)(end_d-start_d)/CLOCKS_PER_SEC;
double time_h = (double)(end_h-start_h)/CLOCKS_PER_SEC;
cudaMemcpy(c, c_d, nBytes, cudaMemcpyDeviceToHost);
printf("Number of elements: %d, GPU Time: %f, CPU Time: %f\n", n, time_d, time_h);
cudaFree(a_d);
cudaFree(b_d);
cudaFree(c_d);
}
return 0;
}
|
2,783 | extern "C" int cSetDevice(int device)
{
return cudaSetDevice(device);
}
|
2,784 | #include <stdint.h>
class Bmp256 { //自定义图像类
#pragma pack(2) // 设定变量以n = 2字节对齐方式
struct Header { // 头信息
uint16_t bfType = 0x4D42;
uint32_t bfSize;
uint16_t bfReserved1 = 0;
uint16_t bfReserved2 = 0;
uint32_t bfOffBits = 54 + 256 * 4;
uint32_t biSize = 40;
int32_t biWidth;
int32_t biHeight;
uint16_t biPlanes = 1;
uint16_t biBitCount = 8;
uint32_t biCompression = 0;
uint32_t biSizeImage = 0;
int32_t biXPelsPerMeter = 0;
int32_t biYPelsPerMeter = 0;
uint32_t biClrUsed = 256;
uint32_t biClrImportant = 256;
} header;
#pragma pack() // 默认值8
int32_t rowSize; // 行大小
struct { // 像素点通道结构
uint8_t B, G, R, A;
void set(uint8_t r, uint8_t g, uint8_t b) { R = r; G = g; B = b; A = 0; } // 设置颜色函数
} palette[256]; // 256个颜色的调色板
uint8_t *buffer = NULL; // 图像缓存
void calc_palette();
public:
Bmp256(int width, int height); // 类构造函数
~Bmp256() { delete[] buffer; } // 类析构函数
int width() const { return header.biWidth; } // 获取图像宽度
int height() const { return header.biHeight; } // 获取图像高度
uint8_t& operator()(int row, int col) { return buffer[row * rowSize + col]; } // get/set the pixel
void save(const char* file); // 保存图像
uint8_t* get_ptr() { return buffer; }; //获取像素
int image_size() { return header.bfSize - header.bfOffBits; };
};
Bmp256::Bmp256(int width, int height) {
header.biWidth = width; // 从头信息中获取宽度和高度
header.biHeight = height;
rowSize = width; // 计算行大小
int buffSize = rowSize * height; // 图像整体缓存的大小
header.bfSize = header.bfOffBits + buffSize;
calc_palette(); // 初始化调色板颜色
buffer = new uint8_t[buffSize]; // 新建图像缓存
}
void Bmp256::calc_palette() {
for (int i = 0; i < 64; ++i) {
palette[i].set(255, 255 - i * 4, 0);
palette[i + 64].set(255 - i * 2, 0, i * 2);
palette[i + 128].set(127 - i * 2, 0, 128 + i * 2);
palette[i + 192].set(0, 0, 255 - i * 3);
}
palette[0].set(0, 0, 0);
}
#include <iostream>
#include <fstream>
void Bmp256::save(const char* file_name) { // 保存
std::ofstream of(file_name, std::ios::binary);
of.write((char *)&header, 54);
of.write((char *)palette, 256 * 4);
char* p = (char *)buffer;
for (int i = 0; i < header.biHeight; ++i) {
of.write(p, rowSize);
p += rowSize;
}
}
const double RMIN = -2, RMAX = 1, IMIN = -1, IMAX = 1;// 实部和虚部的范围
const int W = 12 * 1024; // 宽度：12*1024
const double RESN = W / (RMAX - RMIN); // 实部单位像素数12*1024/（1-(-2)）=4*1024
const int H = (IMAX - IMIN) * RESN; // 高度：（1-(-1)）*4*1024=8*1024
const int MI = 1;
// int Mandelbrot(complex c) { // 曼德博集合是一种在复平面上组成分形的点的集合
// complex z;
// for (int k = 256 * MI - 1; k >= 0; --k) {
// z = z * z + c;
// if (std::norm(z) > 4) return k / MI; //计算分形
// }
// return 0;
// }
#include <ctime>
#include <cuda_runtime.h>
struct cuComplex {
float r;
float i;
__device__ cuComplex( float a, float b ) : r(a), i(b) {}
__device__ float magnitude2( void ) {
return r * r + i * i;
}
__device__ cuComplex operator*(const cuComplex& a) {
return cuComplex(r*a.r - i*a.i, i*a.r + r*a.i);
}
__device__ cuComplex operator+(const cuComplex& a) {
return cuComplex(r+a.r, i+a.i);
}
};
__device__ int Mandelbrot( int x, int y ) {
float jx = RMIN + x / RESN;
float jy = IMIN + y / RESN;
cuComplex a(0, 0);
cuComplex c(jx, jy);
int k = 256 * MI - 1;
for (int k = 256 * MI - 1; k >= 0; --k) {
a = a * a + c;
if (a.magnitude2() > 4) {return k / MI;};
}
return 0;
}
__global__ void kernel( uint8_t *ptr ) {
// map from threadIdx/BlockIdx to position
int x = blockIdx.x;
int y = blockIdx.y;
int offset = x + y * W;
ptr[offset] = Mandelbrot( x, y );
}
int main() {
Bmp256 bmp(W, H);
clock_t t1 = clock();; // 单调计时时钟
uint8_t *dev_bitmap;
cudaMalloc( (void**)&dev_bitmap,
bmp.image_size());
dim3 grid(W, H);
kernel<<<grid,1>>>( dev_bitmap );
cudaMemcpy( bmp.get_ptr(),
dev_bitmap,
bmp.image_size(),
cudaMemcpyDeviceToHost );
cudaFree( dev_bitmap );
clock_t t2 = clock();;
bmp.save("Mandelbrot12k.bmp");
std::cout << "run time: " << (double)(t2 - t1) / CLOCKS_PER_SEC << " seconds.\n";
}
|
2,785 | #include <vector>
#include <iostream>
#define cudaErrCheck(code) if (code != cudaSuccess) throw CudaException{code, __FILE__, __LINE__}
struct CudaException
{
cudaError_t code;
const char * file;
int line;
const char * what() const noexcept { return cudaGetErrorString(code); }
};
__global__ void kernel(int * x, size_t size)
{
size_t id = blockIdx.x * blockDim.x + threadIdx.x;
if (id >= size)
return;
x[id] = id;
}
int main()
{
try
{
size_t size = 1024;
std::vector<int> x(size);
int * dev_x = 0;
cudaErrCheck(cudaMalloc((void **) &dev_x, size * sizeof(int)));
cudaErrCheck(cudaMemcpy(dev_x, &x[0], size * sizeof(int), cudaMemcpyHostToDevice));
size_t num_blocks = 16;
size_t threads_per_block = 64;
kernel<<<num_blocks, threads_per_block>>>(dev_x, size);
cudaErrCheck(cudaPeekAtLastError());
cudaErrCheck(cudaDeviceSynchronize());
cudaErrCheck(cudaMemcpy(&x[0], dev_x, size * sizeof(int), cudaMemcpyDeviceToHost));
cudaErrCheck(cudaFree(dev_x));
for (size_t i = 0; i < size; ++i)
if (i != x[i])
std::cout << "not OK at position: " << i << std::endl;
std::cout << "done" << std::endl;
}
catch (const CudaException & ex)
{
std::cerr << ex.file << ":" << ex.line << " " << ex.what() << std::endl;
return 1;
}
return 0;
}
|
2,786 | #include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdint.h>
#include <string.h>
#include <cuda.h>
#include <cuda_runtime.h>
#define DATAFILE "./data.bin"
#define OUTFILE "./snapshot.bin"
#define STORAGE_SIZE 1085440
#define MAX_FILE_SIZE 1048576
#define G_WRITE 991
#define G_READ 992
#define LS_S 993
#define LS_D 994
#define RM 995
typedef unsigned char uchar;
typedef uint32_t u32t;
typedef struct File_Control_Block{
char filename[20];
int size;
int block_entry;
int modified_time;
}u32;
__device__ __managed__ int nowfile = 0;
__device__ __managed__ int ticking_time = 0;
__device__ __managed__ int sz = 0,addr;
__device__ __managed__ int i,j,k,len,existed,check,valid,found,sp;
__device__ __managed__ uchar temp1,temp2,temp3,temp4,temp5,temp6;
__device__ __managed__ uchar *volume;
void load_bFile(char const* filename , uchar* input , u32t ssz)
{
FILE *myfile;
myfile = fopen(filename,"rb");
fread(input,sizeof(uchar),ssz,myfile);
fclose(myfile);
}
void write_bFile(char const* out , uchar* results , u32t input_size)
{
FILE *myfile;
myfile = fopen(out,"wb");
fwrite(results,sizeof(uchar),input_size,myfile);
fclose(myfile);
}
__device__ int strlens(char const* filename)
{
sz = 0;
for(i = 0 ; i < 20 ; i++)
{
sz++;
if(filename[i]=='\0')
break;
}
return sz;
}
__device__ u32 open(char const* filename, int ACCESS_MODE)
{
u32 temp;
if(ACCESS_MODE == G_WRITE)
{
check = 0;
existed = -1;
len = strlens(filename);
for(i = 0 ; i < 1024 ; i++)
{
if(volume[i] == 1)
{
for(j = 0 ; j < len ; j++)
{
if(filename[j] == volume[1024 + i*26 + j])
check++;
}
if(check == len)
{
existed = i;
}
check = 0;
if(existed != -1)
break;
}
}
if(existed != -1)
{
len = strlens(filename);
for( i = 0 ; i < len ; i++)
{
temp.filename[i] = filename[i];
}
nowfile = existed;
temp.size = volume[1024 + nowfile*26 + 20]*256 + volume[1024 + nowfile*26 + 21];
temp.block_entry = nowfile;
temp.modified_time = volume[1024 + nowfile*26 + 24]*256 + volume[1024 + nowfile*26 + 25];
/*
temp.size = 0;
volume[1024 + nowfile*26 + 20] = temp.size/256;
volume[1024 + nowfile*26 + 21] = temp.size%256;
temp.block_entry = nowfile;
volume[1024 + nowfile*26 + 22] = temp.block_entry/256;
volume[1024 + nowfile*26 + 23] = temp.block_entry%256;
for( i = 0 ; i < len ; i++)
{
volume[1024+nowfile*26+i] = temp.filename[i];
}
for(i = 0 ; i < 1024 ; i++)
{
volume[36864 + temp.block_entry*1024 + i] = 0;
}
ticking_time++;
temp.modified_time = ticking_time;
volume[1024 + nowfile*26 + 24] = temp.modified_time/256;
volume[1024 + nowfile*26 + 25] = temp.modified_time%256;
*/
return temp;
}
else{
len = strlens(filename);
for( i = 0 ; i < len ; i++)
{
temp.filename[i] = filename[i];
}
for(i = 0 ; i < 1024 ; i++)
{
if(volume[i] == 0)
{
nowfile = i;
volume[i] = 1;
break;
}
}
//TODO:err_handle
temp.size = 0;
volume[1024 + nowfile*26 + 20] = 0;
volume[1024 + nowfile*26 + 21] = 0;
temp.block_entry = nowfile;
volume[1024 + nowfile*26 + 22] = temp.block_entry/256;
volume[1024 + nowfile*26 + 23] = temp.block_entry%256;
for( i = 0 ; i < len ; i++)
{
volume[1024+nowfile*26+i] = temp.filename[i];
}
ticking_time++;
temp.modified_time = ticking_time;
volume[1024 + nowfile*26 + 24] = temp.modified_time/256;
volume[1024 + nowfile*26 + 25] = temp.modified_time%256;
return temp;
}
}
else if(ACCESS_MODE == G_READ)
{
check = 0;
existed = -1;
len = strlens(filename);
for(i = 0 ; i < 1024 ; i++)
{
if(volume[i] == 1)
{
for(j = 0 ; j < len ; j++)
{
if(filename[j] == volume[1024 + i*26 + j])
check++;
}
if(check == len)
{
existed = i;
}
check = 0;
}
}
if(existed != -1)
{
for( i = 0 ; i < len ; i++)
{
temp.filename[i] = filename[i];
}
nowfile = existed;
temp.size = volume[1024 + nowfile*26 +20]*256+ volume[1024 + nowfile*26 + 21];
temp.block_entry = nowfile;
temp.modified_time = volume[1024 + nowfile*26 + 24]*256 + volume[1024 + nowfile*26 + 25];
return temp;
}
else
{
//TODO:err handle
printf("No such file can be read\n");
}
}
}
__device__ void write(uchar *startPlace, int data_size, u32 file_pointer)
{
for(i = 0 ; i < file_pointer.size ; i++)
{
volume[36864 + file_pointer.block_entry*1024 + i] = 0;
}
for(i = 0 ; i < data_size ; i++)
{
volume[36864 + file_pointer.block_entry*1024 + i] = *(startPlace+i);
}
file_pointer.size = data_size;
volume[1024 + file_pointer.block_entry*26 + 20] = file_pointer.size/256;
volume[1024 + file_pointer.block_entry*26 + 21] = file_pointer.size%256;
ticking_time++;
file_pointer.modified_time = ticking_time;
volume[1024 + file_pointer.block_entry*26 + 24] = file_pointer.modified_time/256;
volume[1024 + file_pointer.block_entry*26 + 25] = file_pointer.modified_time%256;
}
__device__ void read(uchar *startPlace, int data_size, u32 file_pointer)
{
for(i = 0 ; i < data_size ; i++)
{
*(startPlace+i) = volume[36864 + file_pointer.block_entry*1024 + i];
}
}
__device__ void gsys(int OUTPUT_MODE)
{
if(OUTPUT_MODE == LS_D)
{
printf("===sort by modified time===\n");
for(i = ticking_time ; i > 0 ; i--)
{
for(j = 0 ; j < 1024 ; j++)
{
if(volume[1024 + j*26 + 20] != 255)
{
if(i == (volume[1024 + j*26 + 24]*256+ volume[1024 + j*26 + 25]))
{
for(k = 0 ; k < 20 ; k++)
{
if(volume[1024 + j*26 + k] == '\0')
break;
printf("%c",volume[1024 + j*26 + k]);
}
printf("\n");
}
}
}
}
}
else if(OUTPUT_MODE == LS_S)
{
printf("===sort by file size===\n");
valid = 0;
for( i = 0 ; i < 1024 ; i++ )
{
if( volume[1024 + i*26 + 20] != 255 )
{
volume[27648 + valid*6 ] = volume[ 1024 + i*26 + 20];
volume[27648 + valid*6 + 1] = volume[ 1024 + i*26 + 21];
volume[27648 + valid*6 + 2] = volume[ 1024 + i*26 + 24];
volume[27648 + valid*6 + 3] = volume[ 1024 + i*26 + 25];
volume[27648 + valid*6 + 4] = i/256;
volume[27648 + valid*6 + 5] = i%256;
valid++;
}
}
for(i = valid-1 ; i >0 ; i--)
{
sp=1;
for( j = 0 ; j <= i ; j++)
{
if( ((volume[27648 + j*6]*256) + (volume[27648 + j*6 + 1])) < ((volume[27648 + (j+1)*6]*256) + (volume[27648 + (j+1)*6 + 1])) )
{
temp1 = volume[27648 + j*6];
temp2 = volume[27648 + j*6 + 1 ];
temp3 = volume[27648 + j*6 + 2 ];
temp4 = volume[27648 + j*6 + 3 ];
temp5 = volume[27648 + j*6 + 4 ];
temp6 = volume[27648 + j*6 + 5 ];
volume[27648 + j*6] = volume[27648 + (j+1)*6];
volume[27648 + j*6 + 1 ] = volume[27648 + (j+1)*6 + 1];
volume[27648 + j*6 + 2 ] = volume[27648 + (j+1)*6 + 2];
volume[27648 + j*6 + 3 ] = volume[27648 + (j+1)*6 + 3];
volume[27648 + j*6 + 4 ] = volume[27648 + (j+1)*6 + 4];
volume[27648 + j*6 + 5 ] = volume[27648 + (j+1)*6 + 5];
volume[27648 + (j+1)*6] = temp1;
volume[27648 + (j+1)*6 + 1] = temp2;
volume[27648 + (j+1)*6 + 2] = temp3;
volume[27648 + (j+1)*6 + 3] = temp4;
volume[27648 + (j+1)*6 + 4] = temp5;
volume[27648 + (j+1)*6 + 5] = temp6;
sp=0;
}
else if ( ((volume[27648 + j*6]*256) + (volume[27648 + j*6 + 1])) == ((volume[27648 + (j+1)*6]*256) + (volume[27648 + (j+1)*6 + 1])) )
{
if( ((volume[27648 + j*6 + 2]*256) + (volume[27648 + j*6 + 3])) < ((volume[27648 + (j+1)*6 + 2]*256) + (volume[27648 + (j+1)*6 + 3])) )
{
temp1 = volume[27648 + j*6];
temp2 = volume[27648 + j*6 + 1 ];
temp3 = volume[27648 + j*6 + 2 ];
temp4 = volume[27648 + j*6 + 3 ];
temp5 = volume[27648 + j*6 + 4 ];
temp6 = volume[27648 + j*6 + 5 ];
volume[27648 + j*6] = volume[27648 + (j+1)*6];
volume[27648 + j*6 + 1 ] = volume[27648 + (j+1)*6 + 1];
volume[27648 + j*6 + 2 ] = volume[27648 + (j+1)*6 + 2];
volume[27648 + j*6 + 3 ] = volume[27648 + (j+1)*6 + 3];
volume[27648 + j*6 + 4 ] = volume[27648 + (j+1)*6 + 4];
volume[27648 + j*6 + 5 ] = volume[27648 + (j+1)*6 + 5];
volume[27648 + (j+1)*6] = temp1;
volume[27648 + (j+1)*6 + 1] = temp2;
volume[27648 + (j+1)*6 + 2] = temp3;
volume[27648 + (j+1)*6 + 3] = temp4;
volume[27648 + (j+1)*6 + 4] = temp5;
volume[27648 + (j+1)*6 + 5] = temp6;
}
sp=0;
}
}
if(sp==1) break;
}
for(i = 0 ; i < valid ; i++)
{
addr = volume[27648 + i*6 + 4] * 256 + volume[27648 + i*6 + 5];
for ( j = 0 ; j < 20 ; j++ )
{
if(volume[1024 + addr*26 + j] != '\0')
{
printf("%c",volume[1024 + addr*26 + j]);
}
}
printf(" ");
sz = volume[1024 + addr*26 + 20]*256 + volume[1024 + addr*26 + 21];
printf("%d\n",sz);
}
}
}
__device__ void gsys(int DEL_INFO, char const* filename)
{
len = strlens(filename);
check = 0;
found = 0;
if(DEL_INFO == RM)
{
for(i = 0; i < 1024 ;i++)
{
if(volume[1024 + i*26 + 20] != 255)
{
for(j = 0 ; j < len ; j++)
{
if(volume[1024 + i*26 + j] == filename[j])
check++;
}
if(check == len)
{
found = 1;
int entry = volume[1024 + i*26 + 22]*256 + volume[1024 + i*26 +23];
volume[entry] = 0;
for(k = 0 ; k < 26 ; k++)
volume[1024 + i*26 + k] = 0;
volume[1024 + i*26 + 20] = 255;
for(k = 0 ; k < 1024 ; k++)
volume[36864 + entry*1024 + i] = 0;
}
check = 0;
}
if(found)
break;
}
}
else{
printf("No such command!\n");
}
}
__global__ void mykernel(uchar *input, uchar *output)
{
//####kernel start####
u32 fp = open("t.txt\0", G_WRITE);
write(input, 64, fp);
fp = open("b.txt\0", G_WRITE);
write(input+32, 32, fp);
fp = open("t.txt\0", G_WRITE);
write(input+32, 32, fp);
fp = open("t.txt\0", G_READ);
read(output, 32, fp);
gsys(LS_D);
gsys(LS_S);
fp = open("b.txt\0", G_WRITE);
write(input+64, 12, fp);
gsys(LS_S);
gsys(LS_D);
gsys(RM, "t.txt\0");
gsys(LS_S);
//####kernel end####
}
void init_volume()
{
memset( volume, 0, STORAGE_SIZE );
for( int m = 0 ; m < 1024 ; m++)
volume[ 1024 + m*26 + 20 ] = 255;
}
int main()
{
cudaMallocManaged(&volume,STORAGE_SIZE);
init_volume();
uchar *input, *output;
cudaMallocManaged(&input,MAX_FILE_SIZE);
cudaMallocManaged(&output, MAX_FILE_SIZE);
for(u32t m = 0 ; m < MAX_FILE_SIZE ; m++)
output[m] = 0;
load_bFile(DATAFILE, input, MAX_FILE_SIZE);
cudaSetDevice(1);
mykernel<<<1, 1>>>(input,output);
cudaDeviceSynchronize();
write_bFile(OUTFILE, output, MAX_FILE_SIZE);
cudaDeviceReset();
return 0;
}
|
2,787 | /******************************************************************************
*cr
*cr (C) Copyright 2010 The Board of Trustees of the
*cr University of Illinois
*cr All Rights Reserved
*cr
******************************************************************************/
#include <stdio.h>
#include <device_launch_parameters.h>
#include <curand_kernel.h>
#define trainNum 100000 // number of train data
#define testNum 1000 // number of test data
#define inLayout 10 // number of input layer's neurons
#define hideLayout 8 // number of hidden layer's neurons
#define outLayout 1 // number of output layer's neurons
#define initWeightMax 0.5 // max value of initial weight
#define eta (0.1f) // learn rate
#define iterMax 10000 // max iteration times
#define batchNum 32 // number of batches
#define BLOCKSIZE 16
#define BLOCKSIZE_32 32
/**
* func：initialize weight
* output：weight_D
* input：row row of weight matrix
* input：col column of weight matrix
* input：maxNum max value of weight
*/
__global__ void Bp_Init_Weight(float *weight_D, int row, int col, float maxNum, int seed)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
int index = y_id * col + x_id;
curandState s;
curand_init(index + seed, 0, 0, &s);
if (x_id < col && y_id < row) weight_D[index] = (curand_uniform(&s) - 0.5f) * maxNum;
}
/**
* func：calculate C = A * B' with tiling
* input：dev_A
* input：dev_B
* output：dev_C
* input：heightA row of A matrix
* input：widthA A column of A matrix
* input：heightB row of B matrix
*/
__global__ void MatMulCUDATB(float *dev_A, float *dev_B, float *dev_C, const int heightA, const int widthA, const int heightB)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
float Cvalue = 0;
// loop over tiles in A and B
for (int m = 0; m < widthA; m += BLOCKSIZE)
{
int colA = m + threadIdx.x;
int rowB = m + threadIdx.y;
// use shared memory to stroe Asub and Bsub
__shared__ float As[BLOCKSIZE][BLOCKSIZE];
__shared__ float Bs[BLOCKSIZE][BLOCKSIZE];
// load tile into shared memory
if ((colA < widthA) && (y_id < heightA))
As[threadIdx.y][threadIdx.x] = dev_A[y_id * widthA + colA]; // A(y_id, colA)
else
As[threadIdx.y][threadIdx.x] = 0.0f;
if ((x_id < heightB) && (rowB <widthA))
Bs[threadIdx.y][threadIdx.x] = dev_B[x_id * widthA + rowB]; // B(rowB, x_id)
else
Bs[threadIdx.y][threadIdx.x] = 0.0f;
__syncthreads();
// matrix multiply in tile matrix
for (int idx = 0; idx < BLOCKSIZE; ++idx)
{
Cvalue += As[threadIdx.y][idx] * Bs[idx][threadIdx.x];
}
__syncthreads();
}
if (x_id < heightB && y_id < heightA)
{
dev_C[y_id * heightB + x_id] = Cvalue;
}
}
/**
* func：calculate vector's inner product
* input：As
* input：Bs
* input：length
*/
__device__ inline static float BP_Dot(float *As, float *Bs, int length)
{
float dot = 0.0f;
for (int i = 0; i < length; i++)
{
dot += As[i] * Bs[i];
}
return(dot);
}
/**
* func：calculate input of hidden layer
* input：dev_A
* input：dev_B
* output：dev_C
* input：heightA
* input：widthA
* input：widthB
*/
__global__ void BP_Calculate_HideIn(float *dev_A, float *dev_B, float *dev_C, const int heightA, const int widthA, const int widthB)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
__shared__ float As[BLOCKSIZE_32][BLOCKSIZE_32];
__shared__ float Bs[BLOCKSIZE_32][BLOCKSIZE_32];
As[threadIdx.y][threadIdx.x] = 0.0f;
Bs[threadIdx.y][threadIdx.x] = 0.0f;
if (y_id < heightA && x_id < widthA)
{
As[threadIdx.y][threadIdx.x] = dev_A[threadIdx.y * widthA + x_id];
Bs[threadIdx.y][threadIdx.x] = dev_B[threadIdx.y * widthA + x_id];
}
__syncthreads();
float dot = BP_Dot(As[threadIdx.y], Bs[threadIdx.x], BLOCKSIZE_32);
atomicAdd(&dev_C[threadIdx.y * widthB + threadIdx.x], dot);
}
/**
* func：calculate output of hidden layer
* input：hideOut_D input of hidden layer
* output：hideOut_D output of hidden layer
* input：row
* input：col
*/
__global__ void BP_Calculate_HideOut(float *hideOut_D, int row, int col)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
int index = y_id * col + x_id;
if (x_id < col && y_id < row)
{
hideOut_D[index] = 1.0f / (1.0f + exp(-hideOut_D[index]));
}
}
/**
* func：calculate delta2_D = x_Out - A * B'
* input：dev_A
* input：dev_B
* output：delta2_D delta between hidden layer and output layer
* input：xOut_D
* input：heightA
* input：widthA
* input：heightB
*/
__global__ void BP_Calculate_Delta2(float *dev_A, float *dev_B, float *delta2_D, float *xOut_D, const int heightA, const int widthA, const int heightB)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
float Cvalue = 0;
// loop over tiles in A and B
for (int m = 0; m < widthA; m += BLOCKSIZE)
{
int colA = m + threadIdx.x;
int rowB = m + threadIdx.y;
// use shared memory to stroe Asub and Bsub
__shared__ float As[BLOCKSIZE][BLOCKSIZE];
__shared__ float Bs[BLOCKSIZE][BLOCKSIZE];
// load tile into shared memory
if ((colA < widthA) && (y_id < heightA))
As[threadIdx.y][threadIdx.x] = dev_A[y_id * widthA + colA]; // A(y_id, colA)
else
As[threadIdx.y][threadIdx.x] = 0.0f;
if ((x_id < heightB) && (rowB <widthA))
Bs[threadIdx.y][threadIdx.x] = dev_B[x_id * widthA + rowB]; // B(rowB, x_id)
else
Bs[threadIdx.y][threadIdx.x] = 0.0f;
__syncthreads();
// matrix multiply in tile matrix
for (int idx = 0; idx < BLOCKSIZE; ++idx)
{
Cvalue += As[threadIdx.y][idx] * Bs[idx][threadIdx.x];
}
__syncthreads();
}
if (x_id < heightB && y_id < heightA)
{
int index = y_id * heightB + x_id;
delta2_D[index] = xOut_D[index] - Cvalue;
}
}
/**
* func：calculate C = (hOut .* (1 - hOut)) .* (A * B)
* input：dev_A
* input：dev_B
* output：dev_C
* input：hideOut_D
* input：heightA
* input：widthA
* input：widthB
*/
__global__ void BP_Calculate_Delta1(float *dev_A, float *dev_B, float *dev_C, float *hideOut_D, const int heightA, const int widthA, const int widthB)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
float Cvalue = 0;
// loop over tiles in A and B
for (int m = 0; m < widthA; m += BLOCKSIZE)
{
int colA = m + threadIdx.x;
int rowB = m + threadIdx.y;
// use shared memory to stroe Asub and Bsub
__shared__ float As[BLOCKSIZE][BLOCKSIZE];
__shared__ float Bs[BLOCKSIZE][BLOCKSIZE];
// load tile into shared memory
if ((colA < widthA) && (y_id < heightA))
As[threadIdx.y][threadIdx.x] = dev_A[y_id * widthA + colA]; // A(y_id, colA)
else
As[threadIdx.y][threadIdx.x] = 0.0f;
if ((x_id < widthB) && (rowB <widthA))
Bs[threadIdx.y][threadIdx.x] = dev_B[rowB * widthB + x_id]; // B(rowB, x_id)
else
Bs[threadIdx.y][threadIdx.x] = 0.0f;
__syncthreads();
// matrix multiply in tile matrix
for (int idx = 0; idx < BLOCKSIZE; ++idx)
{
Cvalue += As[threadIdx.y][idx] * Bs[idx][threadIdx.x];
}
__syncthreads();
}
if (x_id < widthB && y_id < heightA)
{
int index = y_id * widthB + x_id;
float data = hideOut_D[index];
dev_C[index] = data * (1.0f - data) * Cvalue;
}
}
/**
* func：update weight C = C + eta/batchNum .* (A' * B)
* input：dev_A
* input：dev_B
* output：dev_C
* input：heightA
* input：widthA
* input：heightB
*/
__global__ void BP_Update_Weight(float *dev_A, float *dev_B, float *dev_C, const int heightA, const int widthA, const int widthB)
{
int x_id = blockDim.x * blockIdx.x + threadIdx.x; // column index
int y_id = blockDim.y * blockIdx.y + threadIdx.y; // row index
float Cvalue = 0;
// loop over tiles in A and B
for (int m = 0; m < heightA; m += BLOCKSIZE)
{
int colA = m + threadIdx.x;
int rowB = m + threadIdx.y;
// use shared memory to stroe Asub and Bsub
__shared__ float As[BLOCKSIZE][BLOCKSIZE];
__shared__ float Bs[BLOCKSIZE][BLOCKSIZE];
// load tile into shared memory
if ((colA < heightA) && (y_id < widthA))
As[threadIdx.y][threadIdx.x] = dev_A[colA * widthA + y_id]; // A(y_id, colA)
else
As[threadIdx.y][threadIdx.x] = 0.0f;
if ((x_id < widthB) && (rowB < heightA))
Bs[threadIdx.y][threadIdx.x] = dev_B[rowB * widthB + x_id]; // B(rowB, x_id)
else
Bs[threadIdx.y][threadIdx.x] = 0.0f;
__syncthreads();
// matrix multiply in tile matrix
for (int idx = 0; idx < BLOCKSIZE; ++idx)
{
Cvalue += As[threadIdx.y][idx] * Bs[idx][threadIdx.x];
}
__syncthreads();
}
if (x_id < widthB && y_id < widthA)
{
dev_C[y_id * widthB + x_id] += eta * Cvalue / float(batchNum);
}
}
/**
* func：calculate error vector
* input：n
* input：A
* input：B
* output：C
*/
__global__ void vectorSub(int n, float *A, float *B, float *C) {
int i = threadIdx.x + blockDim.x * blockIdx.x;
if(i < n){
C[i] = 0.5 * (A[i] - B[i]) * (A[i] - B[i]);
//printf("Thread id is: %d test is: %.5f real is: %.5f Error Vector is: %.5f\n", i, A[i], B[i], C[i]);
}
}
/**
* func：calculate error
* input：n
* input：A
* output：error
*/
__global__ void BP_Calculate_Error(int n, float *A, float *error_D)
{
int i = threadIdx.x + blockIdx.x * blockDim.x;
if(i < n)
{
atomicAdd(&(error_D[0]), A[i]);
//printf("Thread id is: %d, Error is: %.10f\n", i, error_D[0]);
}
}
/*
* func：BP algorithm parallelization version
* input：inputTrain_H input train data
* input：inputTest_H input test data
* input：outputTrain_H train data's label
* input：outputTest_H test data's label
*/
void BpMain(float *inputTrain_H, float *inputTest_H, float *outputTrain_H, float *outputTest_H)
{
/* Allocate device variables */
float *inputTrain_D, *inputTest_D, *outputTrain_D, *outputTest_D;
cudaMalloc((void**)&inputTrain_D, trainNum * inLayout * sizeof(float));
cudaMalloc((void**)&inputTest_D, testNum * inLayout * sizeof(float));
cudaMalloc((void**)&outputTrain_D, trainNum * outLayout * sizeof(float));
cudaMalloc((void**)&outputTest_D, testNum * outLayout * sizeof(float));
float *weightHideIn_D, *weightOutHide_D;
cudaMalloc((void**)&weightHideIn_D, hideLayout * inLayout * sizeof(float));
cudaMalloc((void**)&weightOutHide_D, outLayout * hideLayout * sizeof(float));
float *weightHideInT_D;
cudaMalloc((void**)&weightHideInT_D, hideLayout * inLayout * sizeof(float));
float *deltaHideIn_D, *deltaOutHide_D;
cudaMalloc((void**)&deltaHideIn_D, hideLayout * batchNum * sizeof(float));
cudaMalloc((void**)&deltaOutHide_D, outLayout * batchNum * sizeof(float));
float *hideOut_D, *hideOutTest_D;
cudaMalloc((void**)&hideOut_D, hideLayout * batchNum * sizeof(float));
cudaMemset(hideOut_D, 0, hideLayout * batchNum * sizeof(float));
cudaMalloc((void**)&hideOutTest_D, hideLayout * testNum * sizeof(float));
float *phi_D;
cudaMalloc((void**)&phi_D, hideLayout * batchNum * sizeof(float));
float *yOut_D, *yOutTest_D;
cudaMalloc((void**)&yOut_D, outLayout * batchNum * sizeof(float));
cudaMalloc((void**)&yOutTest_D, outLayout * testNum * sizeof(float));
float *w10 = (float*)malloc(hideLayout * inLayout * sizeof(float));
float *w21 = (float*)malloc(outLayout * hideLayout * sizeof(float));
float *error;
cudaMalloc((void**)&error, testNum * outLayout * sizeof(float));
float *error_H = (float*)malloc(sizeof(float));
float *error_D;
cudaMalloc((void**)&error_D, sizeof(float));
cudaMemset(error_D, 0, sizeof(float));
// Copy host variables to device
cudaMemcpy(inputTrain_D, inputTrain_H, trainNum * inLayout * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(inputTest_D, inputTest_H, testNum * inLayout * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(outputTrain_D, outputTrain_H, trainNum * outLayout * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(outputTest_D, outputTest_H, testNum * outLayout * sizeof(float), cudaMemcpyHostToDevice);
/* Initialize thread block and kernel grid dimensions */
dim3 dimBlock2D(BLOCKSIZE, BLOCKSIZE);
dim3 dimBlock2D_32(BLOCKSIZE_32, BLOCKSIZE_32);
dim3 dimBlock1D(BLOCKSIZE * BLOCKSIZE);
dim3 dimGrid2D_hide_in((inLayout + BLOCKSIZE - 1) / dimBlock2D.x, (hideLayout + BLOCKSIZE - 1) / dimBlock2D.y);
dim3 dimGrid2D_out_hide((hideLayout + BLOCKSIZE - 1) / dimBlock2D.x, (outLayout + BLOCKSIZE - 1) / dimBlock2D.y);
dim3 dimGrid2D_batch_hide((hideLayout + BLOCKSIZE - 1) / dimBlock2D.x, (batchNum + BLOCKSIZE - 1) / dimBlock2D.y);
dim3 dimGrid2D_batch_out((outLayout + BLOCKSIZE - 1) / dimBlock2D.x, (batchNum + BLOCKSIZE - 1) / dimBlock2D.y);
dim3 dimGrid2D_testNum_hide((hideLayout + BLOCKSIZE - 1) / dimBlock2D.x, (testNum + BLOCKSIZE - 1) / dimBlock2D.y);
dim3 dimGrid2D_testNum_out((outLayout + BLOCKSIZE - 1) / dimBlock2D.x, (testNum + BLOCKSIZE - 1) / dimBlock2D.y);
dim3 dimGrid1D_testNum(((testNum + BLOCKSIZE - 1) / dimBlock2D.x));
dim3 dimGrid2D_32_batch_in((inLayout + BLOCKSIZE_32 - 1) / dimBlock2D_32.x, (batchNum + BLOCKSIZE_32 - 1) / dimBlock2D_32.y);
/* weight initiallization */
Bp_Init_Weight<<<dimGrid2D_hide_in, dimBlock2D>>>(weightHideIn_D, hideLayout, inLayout, initWeightMax, 0);
Bp_Init_Weight<<<dimGrid2D_out_hide, dimBlock2D>>>(weightOutHide_D, outLayout, hideLayout, initWeightMax, 393);
for (int i = 0; i < 10000; i++)
{
for (int batch = 0; batch < trainNum; batch += batchNum)
{
/* hIn = X * W01' */
BP_Calculate_HideIn<<<dimGrid2D_32_batch_in, dimBlock2D_32>>>(&inputTrain_D[batch * inLayout], weightHideIn_D, hideOut_D, batchNum, inLayout, hideLayout);
/* hOut = h(hIn) */
BP_Calculate_HideOut<<<dimGrid2D_batch_hide, dimBlock2D>>>(hideOut_D, batchNum, hideLayout);
/* delta2 = xOut - hOut * W21' */
BP_Calculate_Delta2<<<dimGrid2D_batch_out, dimBlock2D>>>(hideOut_D, weightOutHide_D, deltaOutHide_D, &outputTrain_D[batch * outLayout], batchNum, hideLayout, outLayout);
/* delta1 = (hOut .* (1 - hOut)) .* (delta2 * W21) */
BP_Calculate_Delta1<<<dimGrid2D_batch_hide, dimBlock2D>>>(deltaOutHide_D, weightOutHide_D, deltaHideIn_D, hideOut_D, batchNum, outLayout, hideLayout);
/* W21 = W21 + eta / batchNum * delta2' * hOut */
BP_Update_Weight<<<dimGrid2D_out_hide, dimBlock2D>>>(deltaOutHide_D, hideOut_D, weightOutHide_D, batchNum, outLayout, hideLayout);
/* W10 = W10 + eta / batchNum * delta1' * X */
BP_Update_Weight<<<dimGrid2D_hide_in, dimBlock2D>>>(deltaHideIn_D, &inputTrain_D[batch * inLayout], weightHideIn_D, batchNum, hideLayout, inLayout);
}
}
/* test output */
/* hIn = X * W01' */
MatMulCUDATB<<<dimGrid2D_testNum_hide, dimBlock2D>>>(inputTest_D, weightHideIn_D, hideOutTest_D, testNum, inLayout, hideLayout);
/* hOut = h(hIn) */
BP_Calculate_HideOut<<<dimGrid2D_testNum_hide, dimBlock2D>>>(hideOutTest_D, testNum, hideLayout);
/* yOut = hOut * W21' */
MatMulCUDATB<<<dimGrid2D_testNum_out, dimBlock2D>>>(hideOutTest_D, weightOutHide_D, yOutTest_D, testNum, hideLayout, outLayout);
/* calculate error vector */
//printf("Calculate Error Vector\n");
vectorSub<<<dimGrid2D_testNum_out, dimBlock2D>>>(testNum, yOutTest_D, outputTest_D, error);
/* calculate error */
//printf("Calculate Average Error\n");
BP_Calculate_Error<<<dimGrid1D_testNum, dimBlock1D>>>(testNum, error, error_D);
cudaMemcpy(error_H, error_D, sizeof(float), cudaMemcpyDeviceToHost);
printf("BP error is：%.5f%%\n", 100.0f*float(*error_H) / float(testNum));
}
|
2,788 | #include "includes.h"
/*
Copyright (C) 2009-2012 Fraunhofer SCAI, Schloss Birlinghoven, 53754 Sankt Augustin, Germany;
all rights reserved unless otherwise stated.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston,
MA 02111-1307 USA
*/
/** Index function to address the two-dimensional arrays
Q and R
Matrices are stored in column-major order (like Fortran).
i is the row, j is the column (index starts at 1)
ld is the number of elements for each column
*/
#define IDX2F(i,j,ld) ((((j)-1)*(ld))+((i)-1))
/* ---------------------------------------------------------------------- */
/* Tuning can be done by different block sizes. */
#define BLOCK1 64
// 8800 GT: 128 x 1
// C1060: 128 x 1
#define BLOCK1X 64
#define BLOCK1Y 8
// 8800 GT: 64 x 4
// C1060: 64 x 8
#define BLOCK2X 512
#define BLOCK2Y 1
/* ---------------------------------------------------------------------- */
/** Kernel for matrix-vector multiplication
R(k,k:n) = matmulv( Q(1:m,k:n), Q(1:m) )
Same as this BLAS-2 call:
call sgemv('T', m, n-k+1, 1.0, Q(1,k), M, Q(1,k), 1, 0.0, R(k,k), N)
The threads in x-dimension are used for parallelization of
the dot products, the threads in y-dimension compute different
elements of the result vector.
Each thread (t1,t2) will be responsible for BLOCK1X columns and BLOCK1Y
rows of the matrix Q.
*/
/* ---------------------------------------------------------------------- */
/** This kernel scales the row k of the matrix R
R(k,k:n) = R(k,k:n) * S
*/
/* ---------------------------------------------------------------------- */
/** This kernel scales the column k of the matrix Q.
Q(1:m,k) = Q(1:m,k) * S
*/
/* ---------------------------------------------------------------------- */
/** This kernel updates the matrix Q by a product of two vectors.
Q(1:m,k+1:n) -= R(k,k+1:n) * Q(1:m,k)
same as this BLAS-2 call:
call sger(M, N-K, -1.0, Q(1,K), 1, R(K,K+1), N, Q(1,K+1), M)
Each thread (t1,t2) will be responsible for BLOCK2X columns and BLOCK2Y
rows of the matrix Q.
*/
/* ---------------------------------------------------------------------- */
/** QR factorization of a matrix
@param[in] m is number of rows for Q and R
@param[in] n is number of columns for Q and R
@param[in,out] Q is a matrix of size m x n, column major order
@param[out] R is a matrix of size m x n, column major order
@returns 0 if successful
Q(in) = Q(out) * R, where Q(out) is orthonormal and R upper-triangular
*/
__global__ void update(float* Q, float* R, int m, int n, int k)
{
__shared__ float RK[BLOCK2Y];
__shared__ float QK[BLOCK2X];
int tid1 = threadIdx.x;
int tid2 = threadIdx.y;
int j = blockIdx.y * BLOCK2Y + tid2 + k + 1;
if (j < k+1 or j > n) return;
if (tid1 == 0) {
RK[tid2] = R[IDX2F(k,j,n)];
}
for (int i = tid1 + 1; i <= m; i += BLOCK2X ) {
if (tid2 == 0) {
QK[tid1] = Q[IDX2F(i,k,m)];
}
__syncthreads();
Q[IDX2F(i,j,m)] -= QK[tid1] * RK[tid2];
}
} |
2,789 | __global__ void computeDescriptor(
float* desc_out,
unsigned desc_len,
unsigned histsz,
const float* x_in,
const float* y_in,
const unsigned* layer_in,
const float* response_in,
const float* size_in,
const float* ori_in,
unsigned total_feat,
const int d,
const int n,
const float scale,
const float sigma,
const int n_layers)
{
const int tid_x = threadIdx.x;
const int tid_y = threadIdx.y;
const int bsz_x = blockDim.x;
const int bsz_y = blockDim.y;
const int f = blockIdx.y * bsz_y + tid_y;
desc_len = 6;
total_feat = 8;
__shared__ float shrdMem[512];
float* desc = shrdMem;
float* accum = shrdMem + desc_len * histsz;
histsz = 1;
if (f < total_feat) {
const int histlen = 16;
const int hist_off = (tid_x % histsz) * desc_len;
int i = tid_x;
while (i < histlen*histsz) {
desc[tid_y*histlen+i] = 0.f;
i += bsz_x;
}
__syncthreads();
int l = tid_x;
while (l < desc_len*2) {
desc[l ] += desc[l+2*desc_len];
l += bsz_x;
}
__syncthreads();
l = tid_x;
while (l < desc_len) {
desc[l ] += desc[l+desc_len];
l += bsz_x;
}
}
} |
2,790 | #include <stdio.h>
#include <cuda.h>
int main()
{
int deviceCount;
cudaGetDeviceCount(&deviceCount);
printf("Numero di device disponibili %d\n\n\n",deviceCount);
int device;
for (device = 0; device < deviceCount; ++device)
{
cudaDeviceProp deviceProp;
cudaGetDeviceProperties(&deviceProp, device);
printf("Proprieta device %d:\n\n",device);
int canMapHostMemory=deviceProp.canMapHostMemory;
printf("Device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer. %d\n", canMapHostMemory);
int clockRate=deviceProp.clockRate;
printf("Clock frequency in kilohertz. %d\n", clockRate);
int computeMode=deviceProp.computeMode;
printf ("Compute mode (See cudaComputeMode). %d\n",computeMode);
int deviceOverlap=deviceProp.deviceOverlap;
printf("Device can concurrently copy memory and execute a kernel. %d\n",deviceOverlap);
int integrated=deviceProp.integrated;
printf("Device is integrated as opposed to discrete. %d\n",integrated);
int kernelExecTimeoutEnabled=deviceProp.kernelExecTimeoutEnabled;
printf("Specified whether there is a run time limit on kernels. %d\n",kernelExecTimeoutEnabled);
int major=deviceProp.major;
printf("Major compute capability. %d\n",major);
int maxGridSize[3];
maxGridSize[0]=deviceProp.maxGridSize[0];
maxGridSize[1]=deviceProp.maxGridSize[1];
maxGridSize[2]=deviceProp.maxGridSize[2];
printf("Maximum size of each dimension of a grid. %d %d %d\n",maxGridSize[0],maxGridSize[1],maxGridSize[2]);
int maxThreadsDim[3];
maxThreadsDim[0]=deviceProp.maxThreadsDim[0];
maxThreadsDim[1]=deviceProp.maxThreadsDim[1];
maxThreadsDim[2]=deviceProp.maxThreadsDim[2];
printf("Maximum size of each dimension of a block. %d %d %d\n",maxThreadsDim[0],maxThreadsDim[1],maxThreadsDim[2]);
int maxThreadsPerBlock=deviceProp.maxThreadsPerBlock;
printf("Maximum number of threads per block. %d\n",maxThreadsPerBlock);
size_t memPitch=deviceProp.memPitch;
printf("Maximum pitch in bytes allowed by memory copies. %lu\n", (unsigned long) memPitch);
int minor=deviceProp.minor;
printf("Minor compute capability. %d\n",minor);
int multiProcessorCount=deviceProp.multiProcessorCount;
printf("Number of multiprocessors on device. %d\n",multiProcessorCount);
char name[256];
for (int i=0; i<256; i++)
name[i]=deviceProp.name[i];
printf ("ASCII string identifying device. %s\n",name);
int regsPerBlock=deviceProp.regsPerBlock;
printf ("32-bit registers available per block %d\n",regsPerBlock);
size_t sharedMemPerBlock=deviceProp.sharedMemPerBlock;
printf ("Shared memory available per block in bytes. %lu\n", (unsigned long) sharedMemPerBlock);
size_t textureAlignment=deviceProp.textureAlignment;
printf ("Alignment requirement for textures. %lu\n", (unsigned long) textureAlignment);
size_t totalConstMem=deviceProp.totalConstMem;
printf ("Constant memory available on device in bytes. %lu\n", (unsigned long) totalConstMem);
size_t totalGlobalMem=deviceProp.totalGlobalMem;
printf ("Global memory available on device in bytes. %lu\n", (unsigned long) totalGlobalMem);
int warpSize=deviceProp.warpSize;
printf ("Warp size in threads. %d\n", warpSize);
printf("\n");
}
}
|
2,791 | #include <iostream>
#include <time.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <cufft.h>
#define NX 3335 // Чݸ
#define NXWITH0 5000
#define Nfft 128
#define BLOCK_SIZE 32
using std::cout;
using std::endl;
/**
* ܣж cufftComplex Ƿ
* 룺idataA Aͷָ
* 룺idataB Bͷָ
* 룺size Ԫظ
* أtrue | false
*/
bool IsEqual(cufftComplex *idataA, cufftComplex *idataB, const int size)
{
for (int i = 0; i < size; i++)
{
if (abs(idataA[i].x - idataB[i].x) > 0.000001 || abs(idataA[i].y - idataB[i].y) > 0.000001)
return false;
}
return true;
}
/**
* ܣʵ cufftComplex ij߶ţҲdzһ
* 룺idata ͷָ
* odata ͷָ
* 룺size Ԫظ
* 룺scale ų߶
*/
__global__ void CufftComplexScale(cufftComplex *idata, cufftComplex *odata, float scale)
{
//
int x_id = blockDim.x * blockIdx.x + threadIdx.x; //
int y_id = blockDim.y * blockIdx.y + threadIdx.y; //
int index = y_id * NXWITH0 + x_id;
if (x_id < NX && y_id < Nfft)
{
odata[index].x = idata[index].x * scale;
odata[index].y = idata[index].y * scale;
}
}
int main()
{
/* 豸˵ڴռ */
cufftComplex *data_dev;
cudaMalloc((void**)&data_dev, Nfft * NXWITH0 * sizeof(cufftComplex)); // 豸ڴ
cudaMemset(data_dev, 0, Nfft * NXWITH0 * sizeof(cufftComplex)); // ʼΪ0
/* ˵ڴռ */
cufftComplex *data_Host = (cufftComplex*)malloc(Nfft * NXWITH0 * sizeof(cufftComplex)); // ͷָ
cufftComplex *resultIFFT = (cufftComplex*)malloc(Nfft * NXWITH0 * sizeof(cufftComplex)); // 任任Ľ
/* ʼ */
for (int i = 0; i < Nfft; i++)
{
for (int j = 0; j < NXWITH0; j++)
{
int index = i * NXWITH0 + j;
data_Host[index].x = float((rand() * rand()) % NX) / NX;
data_Host[index].y = float((rand() * rand()) % NX) / NX;
}
}
/* ̸߳̿߳ */
dim3 dimBlock2D(BLOCK_SIZE, BLOCK_SIZE);
dim3 dimGrid2D_NXWITH0_Nfft((NXWITH0 + BLOCK_SIZE - 1) / dimBlock2D.x, (Nfft + BLOCK_SIZE - 1) / dimBlock2D.y);
/* cufft */
cufftHandle plan_Nfft_Many; // cuFFT
const int rank = 1; // һά fft
int n[rank] = { Nfft }; // fft źŵijΪ Nfft
int inembed[1] = { 0 }; // ݵ[ҳ]
int onembed[1] = { 10 }; // ݵ[ҳ]
int istride = NXWITH0; // ÿźԪصľ
int idist = 1; // ÿźŵһԪصľ
int ostride = NXWITH0; // ÿźԪصľ
int odist = 1; // ÿźŵһԪصľ
int batch = NX; // fft źŸ
cufftPlanMany(&plan_Nfft_Many, rank, n, inembed, istride, idist, onembed, ostride, odist, CUFFT_C2C, batch);
/* IJ */
cudaMemcpy(data_dev, data_Host, Nfft * NXWITH0 * sizeof(cufftComplex), cudaMemcpyHostToDevice);
cufftExecC2C(plan_Nfft_Many, data_dev, data_dev, CUFFT_FORWARD); // ִ cuFFT任
cufftExecC2C(plan_Nfft_Many, data_dev, data_dev, CUFFT_INVERSE); // ִ cuFFT任
CufftComplexScale<<<dimGrid2D_NXWITH0_Nfft, dimBlock2D>>>(data_dev, data_dev, 1.0f / Nfft); // ϵ
cudaMemcpy(resultIFFT, data_dev, Nfft * NXWITH0 * sizeof(cufftComplex), cudaMemcpyDeviceToHost);
/* پ */
cufftDestroy(plan_Nfft_Many);
/* ͷ豸ռ */
cudaFree(data_dev);
/* */
cout << IsEqual(data_Host, resultIFFT, NX * Nfft) << endl;
return 0;
} |
2,792 | #include<stdio.h>
__global__ void parallel_vector_add(int* d_a, int* d_b, int* d_c, int* d_n) {
int i = (blockIdx.x*blockDim.x) + threadIdx.x;
// printf("I am thread #%d\n", i);
if(i < *d_n) {
printf("I am thread #%d. and about to computer c[%d].\n", i, i);
d_c[i] = d_a[i]+d_b[i];
} else {
printf("I am thread #%d and doing nothing.\n", i);
}
}
int main() {
// allocate and initialize host memory
int n;
scanf("%d", &n);
int h_a[n];
int h_b[n];
int h_c[n];
for(int i = 0; i < n; i++) {
h_a[i] = i;
h_b[i] = n-1;
}
// Part 1: Copy data from host to device
// allocate device memory for a, b, and c
int *d_a, *d_b, *d_c, *d_n;
// copy a and b to device memory
cudaMalloc((void **) &d_a, n*sizeof(int));
cudaMalloc((void **) &d_b, n*sizeof(int));
cudaMalloc((void **) &d_c, n*sizeof(int));
cudaMalloc((void **) &d_n, sizeof(int));
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaMemcpy(d_a, &h_a, n*sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_b, &h_b, n*sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_n, &n, sizeof(int), cudaMemcpyHostToDevice);
// Part 2: Kernel launch
// kernel launch code which let the device performs the actual vector addtion
int numB; // number of block
numB = n%512 ? (n/512)+1 : n/512; // 512 is a number of thread per block.
cudaEventRecord(start);
// 512 is a number of thread per block which can be change without a problem.
parallel_vector_add<<<numB, 512>>>(d_a, d_b, d_c, d_n);
cudaEventRecord(stop);
cudaDeviceSynchronize();
// Part 3: Copy data from device back to host, and free all data allocate on device
cudaMemcpy(&h_c, d_c, n*sizeof(int), cudaMemcpyDeviceToHost);
cudaEventSynchronize(stop);
float milliseconds = 0;
cudaEventElapsedTime(&milliseconds, start, stop);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
for(int i = 0; i < n; i++) {
printf("%d ", h_c[i]);
}
printf("\n Time used: %f milliseconds\n", milliseconds);
}
|
2,793 | #include <iostream>
#include <ctime>
#include <cuda_runtime.h>
#include <cuda_runtime_api.h>
#include <device_launch_parameters.h>
#include <cuda.h>
using namespace std;
void KNearestNeighborsCPU(float3 *dataArray, int *result, int cnt);
__global__ void KNearestNeighborsGPU(float3 *dataArray, int *result, int cnt);
int cnt = 10000;
int main(int argc, char **argv)
{
clock_t init, end;
// generate the data
srand(time(NULL));
int timt = 0;
float3 *dataArray = new float3[cnt];
int *result = new int[cnt];
for (int i = 0; i < cnt; i++)
{
dataArray[i].x = i;
dataArray[i].y = i;
dataArray[i].z = i;
}
// first check the speed of the algorithm takes on the cpu
for (int i = 0; i < 10; i++)
{
init = clock();
KNearestNeighborsCPU(dataArray, result, cnt);
end = clock();
timt += end - init;
cout << "Iteration number " << i << " took " << end - init << " milliseconds" << endl;
}
cout << "[+] The algorithm on the CPU takes " << timt / 10 << " milliseconds" << endl;
timt = 0;
for (int i = 0; i < 10; i++)
cout << i << " - " << result[i] << endl;
memset(result, 0, cnt);
// allocate and copy memory to the gpu
float3 *deviceData;
int *deviceResult;
if (cudaMalloc(&deviceData, sizeof(float3)*cnt) != cudaSuccess)
{
cout << "[+] Unable to allocate GPU memory" << endl;
return -1;
}
if (cudaMalloc(&deviceResult, sizeof(int)*cnt) != cudaSuccess)
{
cout << "[+] Unable to allocate GPU memory" << endl;
return -2;
}
if (cudaMemcpy(deviceData, dataArray, sizeof(float3)*cnt, cudaMemcpyHostToDevice) != cudaSuccess)
{
cout << "[+] Error in moving memory to the GPU" << endl;
return -3;
}
// third check the simple implementation speed on the gpu
for (int i = 0; i < 10; i++)
{
init = clock();
KNearestNeighborsGPU<<< (cnt / 128) + 1, 128 >>>(deviceData, deviceResult, cnt);
cudaMemcpy(result, deviceResult, sizeof(int)*cnt, cudaMemcpyDeviceToHost);
end = clock();
timt += end - init;
cout << "Iteration number " << i << " took " << end - init << " milliseconds" << endl;
}
cout << "[+] The algorithm on the GPU takes " << timt / 10 << " milliseconds" << endl;
timt = 0;
for (int i = 0; i < 10; i++)
cout << i << " - " << result[i] << endl;
return 0;
}
// cpu algorithm
void KNearestNeighborsCPU(float3 *dataArray, int *result, int cnt)
{
for (int i = 0; i < cnt; i++)
{
float minimumDist = 3.4028234664e38f, distance = 0;
for (int j = 0; j < cnt; j++)
{
if (i != j)
{
distance = (dataArray[i].x - dataArray[j].x) * (dataArray[i].x - dataArray[j].x);
distance += (dataArray[i].y - dataArray[j].y) * (dataArray[i].y - dataArray[j].y);
distance += (dataArray[i].z - dataArray[j].z) * (dataArray[i].z - dataArray[j].z);
if (distance < minimumDist)
{
minimumDist = distance;
result[i] = j;
}
}
}
}
}
// gpu algorithm
__global__ void KNearestNeighborsGPU(float3 *dataArray, int *result, int cnt)
{
int id = blockIdx.x * blockDim.x + threadIdx.x;
if (id >= cnt) return;
float3 point = dataArray[id], current;
float minimumDist = 3.4028234664e38f, distance = 0;
for (int j = 0; j < cnt; j++)
{
if (id == j) continue;
current = dataArray[j];
distance = (point.x - current.x) * (point.x - current.x);
distance += (point.y - current.y) * (point.y - current.y);
distance += (point.z - current.z) * (point.z - current.z);
if (distance < minimumDist)
{
minimumDist = distance;
result[id] = j;
}
}
} |
2,794 |
/**
* Copyright 1993-2012 NVIDIA Corporation. All rights reserved.
*
* Please refer to the NVIDIA end user license agreement (EULA) associated
* with this source code for terms and conditions that govern your use of
* this software. Any use, reproduction, disclosure, or distribution of
* this software and related documentation outside the terms of the EULA
* is strictly prohibited.
*/
#include <stdio.h>
#include <stdlib.h>
#include <tiffio.h>
#include <math.h>
#include <iostream>
#include <string.h>
#include <string>
#include <fstream>
#include <sstream>
#include <map>
#include <vector>
#include <algorithm>
#include <time.h>
#include <chrono>
#include <queue>
#include <set>
#include <cuda.h>
static const int WORK_SIZE = 256;
const int AGP = 14, PAS = 15, AGR = 18, CAP = 19, CSP = 20, MAP = 21;
#define CHECK_CUDA_RESULT(N) { \
CUresult result = N; \
if (result != 0) { \
printf("CUDA call on line %d returned error %d\n", __LINE__, \
result); \
exit(1); \
} }
void setup(TIFF* new_tif, int width, int length, int bitsPerSample, int sampleFormat){
TIFFSetField(new_tif, TIFFTAG_IMAGEWIDTH , width);
TIFFSetField(new_tif, TIFFTAG_IMAGELENGTH , length);
TIFFSetField(new_tif, TIFFTAG_BITSPERSAMPLE , bitsPerSample);
TIFFSetField(new_tif, TIFFTAG_SAMPLEFORMAT , sampleFormat);
TIFFSetField(new_tif, TIFFTAG_COMPRESSION , 1);
TIFFSetField(new_tif, TIFFTAG_PHOTOMETRIC , 1);
TIFFSetField(new_tif, TIFFTAG_SAMPLESPERPIXEL, 1);
TIFFSetField(new_tif, TIFFTAG_ROWSPERSTRIP , 1);
TIFFSetField(new_tif, TIFFTAG_RESOLUTIONUNIT , 1);
TIFFSetField(new_tif, TIFFTAG_XRESOLUTION , 1);
TIFFSetField(new_tif, TIFFTAG_YRESOLUTION , 1);
TIFFSetField(new_tif, TIFFTAG_PLANARCONFIG , PLANARCONFIG_CONTIG);
};
void write_line_tiff(TIFF* tif, double tif_line[], int line){
if (TIFFWriteScanline(tif, tif_line, line) < 0){
std::cerr << "Write problem!" << std::endl;
exit(4);
}
};
void write_line_tiff(TIFF* tif, int tif_line[], int line){
if (TIFFWriteScanline(tif, tif_line, line) < 0){
std::cerr << "Write problem!" << std::endl;
exit(4);
}
};
void read_line_tiff(TIFF* tif, double tif_line[], int line){
if(TIFFReadScanline(tif, tif_line, line) < 0){
std::cerr << "Read problem" << std::endl;
exit(3);
}
};
void read_line_tiff(TIFF* tif, int tif_line[], int line){
if(TIFFReadScanline(tif, tif_line, line) < 0){
std::cerr << "Read problem" << std::endl;
exit(3);
}
};
__host__ __device__ bool checkLandCode(int value){
return (value == AGP) || (value == PAS) || (value == AGR) || (value == CAP) || (value == CSP) || (value == MAP);
}
__global__ void landCoverHomogeneity(double* inputBuffer, int* output, int line, int numCol, int numLine){
int column = threadIdx.x + blockIdx.x * blockDim.x;
double pixel_value;
int aux;
while (column < numCol) {
aux = line % 7;
pixel_value = inputBuffer[aux * numCol + column];
output[column] = false;
if(checkLandCode(pixel_value)) { //Verify if the pixel is an AGR pixel
output[column] = true;
for(int i = -3; i <= 3 && output[column]; i++){
for(int j = -3; j <= 3 && output[column]; j++){
// Check if the neighbor is AGR too
if (column + i >= 0 && column + i < numCol && line + j >= 0 && line + j < numLine) {
aux = (line + j) % 7;
pixel_value = inputBuffer[aux * numCol + column];
if(!isnan(pixel_value))
if(!checkLandCode(pixel_value))
output[column] = false;
}
}
}
}
column += blockDim.x * gridDim.x;
}
}
void testLandCoverHomogeneity(TIFF* landCover, TIFF* mask){
uint32 height_band, width_band;
TIFFGetField(landCover, TIFFTAG_IMAGELENGTH, &height_band);
TIFFGetField(landCover, TIFFTAG_IMAGEWIDTH, &width_band);
double* buffer = (double *) malloc(7 * width_band * sizeof(double));
int relation[7] = {-1, -1, -1, -1, -1, -1, -1}, aux;
for(int line = 0; line < height_band; line++) {
// Create the respective line of the binary map of eligibles pixels
int mask_line[width_band];
for(int column = 0; column < width_band; column++) {
int pixel_value;
aux = line % 7;
if(relation[aux] != line) {
read_line_tiff(landCover, buffer + aux * width_band, line);
relation[aux] = line;
}
pixel_value = buffer[aux * width_band + column];
mask_line[column] = false;
if(checkLandCode(pixel_value)) { //Verify if the pixel is an AGR pixel
mask_line[column] = true;
for(int i = -3; i <= 3 && mask_line[column]; i++){
for(int j = -3; j <= 3 && mask_line[column]; j++){
// Check if the neighbor is AGR too
if (column + i >= 0 && column + i < width_band && line + j >= 0 && line + j < height_band) {
aux = (line + j) % 7;
if(relation[aux] != (line + j)) {
read_line_tiff(landCover, buffer + aux * width_band, line + j);
relation[aux] = (line + j);
}
pixel_value = buffer[aux * width_band + column];
if(!std::isnan(pixel_value))
if(!checkLandCode(pixel_value))
mask_line[column] = false;
}
}
}
}
}
write_line_tiff(mask, mask_line, line);
}
// for(int i = 0; i < 7; i++){
// free(buffer[i]);
// }
free(buffer);
}
int main(int argc, char **argv) {
std::string landCoverPath = argv[1];
std::string outputPath = argv[2];
std::string outputCPU = outputPath + "/CPU.tif";
std::string outputGPU = outputPath + "/GPU.tif";
TIFF* landCover = TIFFOpen(landCoverPath.c_str(), "rm");
uint32 height_band, width_band;
TIFFGetField(landCover, TIFFTAG_IMAGEWIDTH, &width_band);
TIFFGetField(landCover, TIFFTAG_IMAGELENGTH, &height_band);
TIFF* CPU = TIFFOpen(outputCPU.c_str(), "w8m");
setup(CPU, width_band, height_band, 32, 2);
testLandCoverHomogeneity(landCover, CPU);
TIFFClose(CPU);
TIFF* GPU = TIFFOpen(outputGPU.c_str(), "w8m");
setup(GPU, width_band, height_band, 32, 2);
double* buffer = (double *) malloc(7 * width_band * sizeof(double));
int* output_line = (int*) malloc(width_band * sizeof(int));
double* buffer_dev;
cudaMalloc((void**) &buffer_dev, 7 * width_band * sizeof(double*));
int* output_dev;
cudaMalloc((void**) &output_dev, width_band * sizeof(int*));
int relation[7] = {-1, -1, -1, -1, -1, -1, -1};
for(int line = 0; line < height_band; line++) {
for(int i = -3; i < 4; i++) {
if(line + i >= 0 && line + i < height_band){
if(relation[(line + i) % 7] != (line + i)) {
read_line_tiff(landCover, buffer + ((line + i) % 7) * width_band, line + i);
relation[(line + i) % 7] = line + i;
}
}
}
cudaMemcpy(buffer_dev, buffer, 7 * width_band * sizeof(double), cudaMemcpyHostToDevice);
landCoverHomogeneity<<< (width_band + 1) / WORK_SIZE , WORK_SIZE>>>(buffer_dev, output_dev, line, width_band, height_band);
cudaMemcpy(output_line, output_dev, width_band * sizeof(int), cudaMemcpyDeviceToHost);
write_line_tiff(GPU, output_line, line);
}
free(buffer);
free(output_line);
cudaFree(buffer_dev);
cudaFree(output_dev);
TIFFClose(landCover);
TIFFClose(GPU);
return 0;
}
|
2,795 | #include "includes.h"
/** Modifed version of knn-CUDA from https://github.com/vincentfpgarcia/kNN-CUDA
* The modifications are
* removed texture memory usage
* removed split query KNN computation
* added feature extraction with bilinear interpolation
*
* Last modified by Christopher B. Choy <chrischoy@ai.stanford.edu> 12/23/2016
*/
// Includes
// Constants used by the program
#define BLOCK_DIM 16
#define DEBUG 0
/**
* Computes the distance between two matrix A (reference points) and
* B (query points) containing respectively wA and wB points.
*
* @param A pointer on the matrix A
* @param wA width of the matrix A = number of points in A
* @param B pointer on the matrix B
* @param wB width of the matrix B = number of points in B
* @param dim dimension of points = height of matrices A and B
* @param AB pointer on the matrix containing the wA*wB distances computed
*/
/**
* Gathers k-th smallest distances for each column of the distance matrix in the top.
*
* @param dist distance matrix
* @param ind index matrix
* @param width width of the distance matrix and of the index matrix
* @param height height of the distance matrix and of the index matrix
* @param k number of neighbors to consider
*/
/**
* Computes the square root of the first line (width-th first element)
* of the distance matrix.
*
* @param dist distance matrix
* @param width width of the distance matrix
* @param k number of neighbors to consider
*/
//-----------------------------------------------------------------------------------------------//
// K-th NEAREST NEIGHBORS //
//-----------------------------------------------------------------------------------------------//
/**
* K nearest neighbor algorithm
* - Initialize CUDA
* - Allocate device memory
* - Copy point sets (reference and query points) from host to device memory
* - Compute the distances + indexes to the k nearest neighbors for each query point
* - Copy distances from device to host memory
*
* @param ref_host reference points ; pointer to linear matrix
* @param ref_nb number of reference points ; width of the matrix
* @param query_host query points ; pointer to linear matrix
* @param query_nb number of query points ; width of the matrix
* @param dim dimension of points ; height of the matrices
* @param k number of neighbor to consider
* @param dist_host distances to k nearest neighbors ; pointer to linear matrix
* @param dist_host indexes of the k nearest neighbors ; pointer to linear matrix
*
*/
__global__ void cuInsertionSort(float *dist, long *ind, int width, int height, int k){
// Variables
int l, i, j;
float *p_dist;
long *p_ind;
float curr_dist, max_dist;
long curr_row, max_row;
unsigned int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
if (xIndex<width){
// Pointer shift, initialization, and max value
p_dist = dist + xIndex;
p_ind = ind + xIndex;
max_dist = p_dist[0];
p_ind[0] = 1;
// Part 1 : sort kth firt elementZ
for (l=1; l<k; l++){
curr_row = l * width;
curr_dist = p_dist[curr_row];
if (curr_dist<max_dist){
i=l-1;
for (int a=0; a<l-1; a++){
if (p_dist[a*width]>curr_dist){
i=a;
break;
}
}
for (j=l; j>i; j--){
p_dist[j*width] = p_dist[(j-1)*width];
p_ind[j*width] = p_ind[(j-1)*width];
}
p_dist[i*width] = curr_dist;
p_ind[i*width] = l+1;
} else {
p_ind[l*width] = l+1;
}
max_dist = p_dist[curr_row];
}
// Part 2 : insert element in the k-th first lines
max_row = (k-1)*width;
for (l=k; l<height; l++){
curr_dist = p_dist[l*width];
if (curr_dist<max_dist){
i=k-1;
for (int a=0; a<k-1; a++){
if (p_dist[a*width]>curr_dist){
i=a;
break;
}
}
for (j=k-1; j>i; j--){
p_dist[j*width] = p_dist[(j-1)*width];
p_ind[j*width] = p_ind[(j-1)*width];
}
p_dist[i*width] = curr_dist;
p_ind[i*width] = l+1;
max_dist = p_dist[max_row];
}
}
}
} |
2,796 | #include <stdio.h>
__global__ void hellokernel()
{
printf("Hello World!\n");
}
int main(void)
{
int num_threads = 10;
int num_blocks = 10;
hellokernel<<<num_blocks,num_threads>>>();
cudaDeviceSynchronize();
return 0;
}
|
2,797 | #include <iostream>
#include <vector>
__global__ void vecmabite( int *out, int *in, std::size_t size )
{
auto tid = threadIdx.x;
out[ tid ] = in[ 2 * tid ];
}
int main()
{
std::vector< int > out( 50 );
std::vector< int > in( 100 );
int * out_d = nullptr;
int * in_d = nullptr;
for( std::size_t i = 0 ; i < in.size() ; ++i )
{
in[ i ] = i;
}
cudaMalloc( &out_d, out.size() * sizeof( int ) );
cudaMalloc( &in_d, in.size() * sizeof( int ) );
cudaMemcpy( in_d, in.data(), in.size() * sizeof( int ), cudaMemcpyHostToDevice );
vecmabite<<< 1, 100 >>>( out_d, in_d, out.size() );
cudaMemcpy( out.data(), out_d, out.size() * sizeof( int ), cudaMemcpyDeviceToHost );
for( auto const x: out )
{
std::cout << x << std::endl;
}
cudaFree( out_d );
cudaFree( in_d );
return 0;
}
|
2,798 | // #define DEBUG_MODE 1
#include <stdio.h>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <thrust/reduce.h>
#include <thrust/device_ptr.h>
#include <thrust/device_malloc_allocator.h>
__global__ void move_nodes(int n_tot, int m_tot, int *d_col_idx, int *d_weights, int *d_prefix_sums, int *d_degrees, int *d_community_idx, int *d_community_degrees, int *d_tmp_community_idx, int *d_tmp_community_degrees, float resolution) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if(i < n_tot) {
//define neighbour range
int start = 0;
if (i>0) {
start = d_prefix_sums[i-1];
}
int end = d_prefix_sums[i];
int deg_i = d_degrees[i];
//modularity
int current_comm = d_community_idx[i];
int new_comm = current_comm;
float local_q = 0;
float max_q = 0;
//iterate over neighbours of i
for(int j = start; j < end; j++) {
int col = d_col_idx[j];
//get community of neighbour
int col_comm = d_community_idx[col];
int k_comm = d_community_degrees[col_comm]; //degree of community
// The singlet minimum HEURISTIC
if(i == current_comm && deg_i == d_community_degrees[current_comm] && col == col_comm && d_degrees[col] == k_comm && col_comm > current_comm) {
#ifdef DEBUG_MODE
if(i == 0) {
printf("$$$");
printf("SKIP CHANGE %d to %d \n", i, col);
printf("$$$");
}
#endif
continue;
}
// int k_i_comm = col_weights[j]; //sum of weights of edges joining i with community
int k_i_comm = 0; //sum of weights of edges joining i with community
//search for other neighbors from this community
for(int n = start; n < end; n++) {
int col_n = d_col_idx[n];
//check if its from the same community
if(d_community_idx[col_n] != col_comm) {
continue;
}
// k_i_comm += d_weights[n];
k_i_comm++;
}
local_q = (1.0 / (float)m_tot) * ((float)k_i_comm - (resolution * (float)deg_i * (float)k_comm / (2.0 * (float)m_tot)));
#ifdef DEBUG_MODE
if(i == 0) {
printf("=============== \n");
printf("migrate %d to %d \n", i, col_comm);
printf("m_tot = %d \n", m_tot);
// printf("comm_inter_deg = %d \n", comm_inter_deg);
printf("k_i_comm = %d \n", k_i_comm);
printf("deg_i = %d \n", deg_i);
printf("k_comm = %d \n", k_comm);
printf("local_q = %f \n", local_q);
}
#endif
if(local_q >= max_q) {
if(local_q == max_q && new_comm < col_comm) {
//do nothing
} else {
#ifdef DEBUG_MODE
if(i ==0) {
printf("$$$$$ \n");
printf("migrated [%d] from %d to %d \n", i, new_comm, col_comm);
printf("previous q: %f , current q: %f \n", max_q, local_q);
printf("$$$$$ \n");
}
#endif
new_comm = col_comm;
max_q = local_q;
}
}
}
d_tmp_community_idx[i] = new_comm;
atomicSub(&d_tmp_community_degrees[current_comm], deg_i);
atomicAdd(&d_tmp_community_degrees[new_comm], deg_i);
}
}
__global__ void calculate_community_internal_edges(int n_tot, int *d_col_idx, int *d_weights, int *d_prefix_sums, int *d_tmp_community_idx, int *d_tmp_community_inter) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if(i < n_tot) {
int inter_count = 0;
//define neighbour range
int start = 0;
if (i>0) {
start = d_prefix_sums[i-1];
}
int end = d_prefix_sums[i];
int current_comm = d_tmp_community_idx[i];
//iterate over neighbours of i
for (int j = start; j < end; j++) {
int col = d_col_idx[j];
if (d_tmp_community_idx[col] == current_comm) {
// inter_count += d_weights[j];
inter_count++;
}
}
d_tmp_community_inter[i] = inter_count;
}
}
__global__ void calculate_community_internal_sum(int n_tot, int *d_tmp_community_idx, int *d_tmp_community_inter, int *d_tmp_community_inter_sum) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if(i < n_tot) {
int comm_sum = 0;
for(int j = 0; j < n_tot; j++) {
if(d_tmp_community_idx[j] == i) {
comm_sum += d_tmp_community_inter[j];
}
}
// edges are bidirectional
d_tmp_community_inter_sum[i] = comm_sum / 2;
}
}
__global__ void calculate_part_modularity(int n_tot, int m_tot, int *d_tmp_community_inter_sum, int *d_tmp_community_degrees, float *d_part_mod, float resolution) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if(i < n_tot) {
float lc = (float)d_tmp_community_inter_sum[i];
float kc = (float)d_tmp_community_degrees[i];
float m = (float)m_tot;
d_part_mod[i] = ( ( lc/m ) - (resolution * pow((kc)/(2*m), 2.0f)) );
}
}
// -----------------------------------------------
int * kernel_wrapper(int n, int m_edges, int *col_idx, int *prefix_sums, int *degrees, float resolution, float threshold) {
int block_size = 1024; //thread block size
int nblocks = int(ceilf(n/(float)block_size)); //problem size divided by thread block size rounded up
dim3 grid(nblocks, 1);
dim3 threads(block_size, 1, 1);
cudaError_t err;
int m_tot = m_edges/2;
int *h_community_idx = (int *) malloc(n*sizeof(int));
std::iota(h_community_idx, h_community_idx + n, 0);
// define GPU memory pointers
int *d_col_idx;
int *d_prefix_sums;
int *d_degrees;
int *h_weights = (int *) malloc(m_edges*sizeof(int));
std::fill_n(h_weights, m_edges, 1);
int *d_weights;
int *d_community_idx;
int *d_community_degrees;
int *d_tmp_community_idx;
int *d_tmp_community_degrees;
int *d_tmp_community_inter;
int *d_tmp_community_inter_sum;
float *d_part_mod;
// allocate GPU memory
err = cudaMalloc((void **)&d_col_idx, m_edges*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_col_idx: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_prefix_sums, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_prefix_sums: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_degrees, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_degrees: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_weights, m_edges*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_weights: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_community_idx, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_community_idx: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_community_degrees, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_community_degrees: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_tmp_community_idx, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_tmp_community_idx: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_tmp_community_degrees, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_tmp_community_idx: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_tmp_community_inter, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_tmp_community_inter: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_tmp_community_inter_sum, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_tmp_community_inter_sum: %s\n", cudaGetErrorString( err ));
err = cudaMalloc((void **)&d_part_mod, n*sizeof(float));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMalloc d_part_mod: %s\n", cudaGetErrorString( err ));
// copy data to GPU
err = cudaMemcpy(d_col_idx, col_idx, m_edges*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device col_idx: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_prefix_sums, prefix_sums, n*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device prefix_sums: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_degrees, degrees, n*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device d_degrees: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_weights, h_weights, m_edges*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device d_weights: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_community_idx, h_community_idx, n*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device h_community_idx: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_community_degrees, degrees, n*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device d_community_degrees: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_tmp_community_idx, h_community_idx, n*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device d_tmp_community_idx: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_tmp_community_degrees, degrees, n*sizeof(int), cudaMemcpyHostToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy host to device d_tmp_community_degrees: %s\n", cudaGetErrorString( err ));
float phase_modularity = 0;
while(true) {
// 1. Calculate best moves
move_nodes<<<grid, threads>>>(n, m_tot, d_col_idx, d_weights, d_prefix_sums, d_degrees, d_community_idx, d_community_degrees, d_tmp_community_idx, d_tmp_community_degrees, resolution);
// 2. Calculate internal edges
// todo: efficient way of creating 0 array every iteration
err = cudaMemset(d_tmp_community_inter, 0, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemset d_tmp_community_inter: %s\n", cudaGetErrorString( err ));
err = cudaMemset(d_tmp_community_inter_sum, 0, n*sizeof(int));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemset d_tmp_community_inter_sum: %s\n", cudaGetErrorString( err ));
err = cudaMemset(d_part_mod, 0, n*sizeof(float));
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemset d_part_mod: %s\n", cudaGetErrorString( err ));
calculate_community_internal_edges<<<grid, threads>>>(n, d_col_idx, d_weights, d_prefix_sums, d_tmp_community_idx, d_tmp_community_inter);
calculate_community_internal_sum<<<grid, threads>>>(n, d_tmp_community_idx, d_tmp_community_inter, d_tmp_community_inter_sum);
calculate_part_modularity<<<grid, threads>>>(n, m_tot, d_tmp_community_inter_sum, d_tmp_community_degrees, d_part_mod, resolution);
thrust::device_ptr<float> mod_ptr = thrust::device_pointer_cast(d_part_mod);
float current_modularity = thrust::reduce(mod_ptr, mod_ptr + n);
// printf("RESOLUTION: %.1f | MODULARITY: %.6f\n", resolution, current_modularity);
if((current_modularity - phase_modularity)/phase_modularity <= threshold) {
break;
} else {
phase_modularity = current_modularity;
err = cudaMemcpy(d_community_idx, d_tmp_community_idx, n*sizeof(int), cudaMemcpyDeviceToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy device to device d_community_idx: %s\n", cudaGetErrorString( err ));
err = cudaMemcpy(d_community_degrees, d_tmp_community_degrees, n*sizeof(int), cudaMemcpyDeviceToDevice);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy device to device d_community_degrees: %s\n", cudaGetErrorString( err ));
}
}
// copy the result to host
err = cudaMemcpy(h_community_idx, d_tmp_community_idx, n*sizeof(int), cudaMemcpyDeviceToHost);
if (err != cudaSuccess) fprintf(stderr, "Error in cudaMemcpy device to host h_community_idx: %s\n", cudaGetErrorString( err ));
cudaFree(d_col_idx);
cudaFree(d_prefix_sums);
cudaFree(d_degrees);
cudaFree(d_community_idx);
cudaFree(d_community_degrees);
cudaFree(d_tmp_community_idx);
return h_community_idx;
} |
2,799 |
#include <stdio.h>
#include <sys/time.h>
__global__ void square( int * d_in,int n){
int totalSum;
if (threadIdx.x == 0) totalSum = 0;
__syncthreads();
int localVal = d_in[threadIdx.x];
for(int i=0;i<n;i++)
atomicAdd(&totalSum, 1);
__syncthreads();
}
int main(int argc, char ** argv) {
const int ARRAY_SIZE = 64;
const int ARRAY_BYTES = ARRAY_SIZE * sizeof(float);
// generate the input array on the host
int h_in[ARRAY_SIZE];
for (int i = 0; i < ARRAY_SIZE; i++) {
h_in[i] = i;
}
int * d_in;
cudaMalloc((void**) &d_in, ARRAY_BYTES);
// cudaMalloc((void*) &totalSum, sizeof(float));
cudaMemcpy(d_in, h_in, ARRAY_BYTES, cudaMemcpyHostToDevice);
for(int i=100;i<1000;i+=10){
struct timeval tv1, tv2;
gettimeofday(&tv1, NULL);
for(int j=0;j<1000000;j++)
square<<<1, 64>>>(d_in,i);
gettimeofday(&tv2, NULL);
printf ("%d\t%f\n",i,
(double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
(double) (tv2.tv_sec - tv1.tv_sec));
}
// cudaMemcpy(ans, totalSum, sizeof(float), cudaMemcpyDeviceToHost);
// printf("%f\n",ans);
cudaFree(d_in);
return 0;
}
|
2,800 | #include "includes.h"
__global__ void stencilShared1(float *src, float *dst, int size)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
__shared__ float buffer[1024+21];
for(int i = threadIdx.x; i < 1024+21; i = i + 1024)
{
buffer[i] = src[idx+i];
}
idx += 11;
if (idx >= size)
return;
__syncthreads();
float out = 0;
#pragma unroll
for(int i = -10;i < 10; i++)
{
out += buffer[threadIdx.x+10+i] * const_stencilWeight[i+10];
}
dst[idx] = out;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.