#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ pbuf;
typedef int /*<<< orphan*/ log;
typedef int cl_uint;
typedef int /*<<< orphan*/ cl_program;
typedef int /*<<< orphan*/ cl_platform_id;
typedef int /*<<< orphan*/ cl_mem;
typedef int /*<<< orphan*/ cl_kernel;
typedef scalar_t__ cl_int;
typedef int /*<<< orphan*/ cl_device_id;
typedef int /*<<< orphan*/ cl_context_properties;
typedef int /*<<< orphan*/ cl_context;
typedef int /*<<< orphan*/ cl_command_queue;

/* Variables and functions */
int /*<<< orphan*/ CL_CONTEXT_DEVICES;
int /*<<< orphan*/ CL_CONTEXT_PLATFORM;
int /*<<< orphan*/ CL_DEVICE_NAME;
int /*<<< orphan*/ CL_DEVICE_TYPE_ALL;
int /*<<< orphan*/ CL_MEM_READ_WRITE;
int /*<<< orphan*/ CL_PLATFORM_VENDOR;
int /*<<< orphan*/ CL_PROGRAM_BUILD_LOG;
scalar_t__ CL_SUCCESS;
int /*<<< orphan*/ CL_TRUE;
scalar_t__ clBuildProgram(int /*<<< orphan*/, int, int /*<<< orphan*/ *, char *,
                          int /*<<< orphan*/ *, int /*<<< orphan*/ *);
int /*<<< orphan*/ clCreateBuffer(int /*<<< orphan*/, int /*<<< orphan*/, int,
                                  int /*<<< orphan*/ *, scalar_t__ *);
int /*<<< orphan*/ clCreateCommandQueue(int /*<<< orphan*/, int /*<<< orphan*/,
                                        int /*<<< orphan*/, scalar_t__ *);
int /*<<< orphan*/ clCreateContextFromType(int /*<<< orphan*/ *,
                                           int /*<<< orphan*/,
                                           int /*<<< orphan*/ *,
                                           int /*<<< orphan*/ *, scalar_t__ *);
int /*<<< orphan*/ clCreateKernel(int /*<<< orphan*/, char *, scalar_t__ *);
int /*<<< orphan*/ clCreateProgramWithSource(int /*<<< orphan*/, int,
                                             char const **, size_t *,
                                             scalar_t__ *);
scalar_t__ clEnqueueNDRangeKernel(int /*<<< orphan*/, int /*<<< orphan*/, int,
                                  int /*<<< orphan*/ *, size_t *, size_t *,
                                  int /*<<< orphan*/, int /*<<< orphan*/ *,
                                  int /*<<< orphan*/ *);
scalar_t__ clEnqueueReadBuffer(int /*<<< orphan*/, int /*<<< orphan*/,
                               int /*<<< orphan*/, int /*<<< orphan*/, int,
                               float *, int /*<<< orphan*/,
                               int /*<<< orphan*/ *, int /*<<< orphan*/ *);
scalar_t__ clEnqueueWriteBuffer(int /*<<< orphan*/, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int, ...);
scalar_t__ clFinish(int /*<<< orphan*/);
scalar_t__ clFlush(int /*<<< orphan*/);
scalar_t__ clGetContextInfo(int /*<<< orphan*/, int /*<<< orphan*/, size_t,
                            int /*<<< orphan*/ *, size_t *);
scalar_t__ clGetDeviceInfo(int /*<<< orphan*/, int /*<<< orphan*/, int, char *,
                           int /*<<< orphan*/ *);
scalar_t__ clGetPlatformIDs(int, int /*<<< orphan*/ *, int *);
scalar_t__ clGetPlatformInfo(int /*<<< orphan*/, int /*<<< orphan*/, int,
                             char *, int /*<<< orphan*/ *);
int /*<<< orphan*/ clGetProgramBuildInfo(int /*<<< orphan*/, int /*<<< orphan*/,
                                         int /*<<< orphan*/, int, char *,
                                         int /*<<< orphan*/ *);
scalar_t__ clReleaseCommandQueue(int /*<<< orphan*/);
scalar_t__ clReleaseContext(int /*<<< orphan*/);
scalar_t__ clReleaseKernel(int /*<<< orphan*/);
scalar_t__ clReleaseMemObject(int /*<<< orphan*/);
scalar_t__ clReleaseProgram(int /*<<< orphan*/);
scalar_t__ clSetKernelArg(int /*<<< orphan*/, int, int, void *);
int /*<<< orphan*/ fatal_CL(scalar_t__, int);
int /*<<< orphan*/ fflush(int /*<<< orphan*/ *);
char *load_kernel_source(char *);
scalar_t__ malloc(size_t);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sprintf(char *, char *);
size_t strlen(char const *);
scalar_t__ strstr(char *, char *);
void kernel_gpu_opencl_wrapper(float *image, int Nr, int Nc, long Ne, int niter,
                               float lambda, long NeROI, int *iN, int *iS,
                               int *jE, int *jW, int iter, int mem_size_i,
                               int mem_size_j) {
  cl_int error;
  cl_uint num_platforms;
  error = clGetPlatformIDs(0, NULL, &num_platforms);
  if (error != CL_SUCCESS)
    fatal_CL(error, 82);
  cl_platform_id *platforms =
      (cl_platform_id *)malloc(sizeof(cl_platform_id) * num_platforms);
  error = clGetPlatformIDs(num_platforms, platforms, NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 90);
  cl_platform_id platform = platforms[0];
  char pbuf[100];
  error =
      clGetPlatformInfo(platform, CL_PLATFORM_VENDOR, sizeof(pbuf), pbuf, NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 103);
  printf("Platform: %s\n", pbuf);
  cl_context_properties context_properties[3] = {
      CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0};
  cl_context context;
  context = clCreateContextFromType(context_properties, CL_DEVICE_TYPE_ALL,
                                    NULL, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 123);
  size_t devices_size;
  error = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &devices_size);
  if (error != CL_SUCCESS)
    fatal_CL(error, 137);
  cl_device_id *devices = (cl_device_id *)malloc(devices_size);
  error = clGetContextInfo(context, CL_CONTEXT_DEVICES, devices_size, devices,
                           NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 147);
  cl_device_id device;
  device = devices[0];
  error = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(pbuf), pbuf, NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 160);
  printf("Device: %s\n", pbuf);
  cl_command_queue command_queue;
  command_queue = clCreateCommandQueue(context, device, 0, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 174);
  const char *source = load_kernel_source("./kernel/kernel_gpu_opencl.cl");
  size_t sourceSize = strlen(source);
  cl_program program =
      clCreateProgramWithSource(context, 1, &source, &sourceSize, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 191);
  char clOptions[150];
  sprintf(clOptions, "-I.");
  error = clBuildProgram(program, 1, &device, clOptions, NULL, NULL);
  static char log[65536];
  memset(log, 0, sizeof(log));
  clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, sizeof(log) - 1,
                        log, NULL);
  printf("-----OpenCL Compiler Output-----\n");
  if (strstr(log, "warning:") || strstr(log, "error:"))
    printf("<<<<\n%s\n>>>>\n", log);
  printf("--------------------------------\n");
  if (error != CL_SUCCESS)
    fatal_CL(error, 227);
  cl_kernel extract_kernel;
  extract_kernel = clCreateKernel(program, "extract_kernel", &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 239);
  cl_kernel prepare_kernel;
  prepare_kernel = clCreateKernel(program, "prepare_kernel", &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 247);
  cl_kernel reduce_kernel;
  reduce_kernel = clCreateKernel(program, "reduce_kernel", &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 255);
  cl_kernel srad_kernel;
  srad_kernel = clCreateKernel(program, "srad_kernel", &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 263);
  cl_kernel srad2_kernel;
  srad2_kernel = clCreateKernel(program, "srad2_kernel", &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 271);
  cl_kernel compress_kernel;
  compress_kernel = clCreateKernel(program, "compress_kernel", &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 279);
  int blocks_x;
  int mem_size;
  mem_size = sizeof(float) * Ne;
  cl_mem d_I;
  d_I = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 316);
  cl_mem d_iN;
  d_iN = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size_i, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 329);
  cl_mem d_iS;
  d_iS = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size_i, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 338);
  cl_mem d_jE;
  d_jE = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size_j, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 347);
  cl_mem d_jW;
  d_jW = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size_j, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 356);
  cl_mem d_dN;
  d_dN = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 369);
  cl_mem d_dS;
  d_dS = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 378);
  cl_mem d_dW;
  d_dW = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 387);
  cl_mem d_dE;
  d_dE = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 396);
  cl_mem d_c;
  d_c = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 409);
  cl_mem d_sums;
  d_sums = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 422);
  cl_mem d_sums2;
  d_sums2 = clCreateBuffer(context, CL_MEM_READ_WRITE, mem_size, NULL, &error);
  if (error != CL_SUCCESS)
    fatal_CL(error, 431);
  error =
      clEnqueueWriteBuffer(command_queue, d_I, 1, 0, mem_size, image, 0, 0, 0);
  if (error != CL_SUCCESS)
    fatal_CL(error, 455);
  error =
      clEnqueueWriteBuffer(command_queue, d_iN, 1, 0, mem_size_i, iN, 0, 0, 0);
  if (error != CL_SUCCESS)
    fatal_CL(error, 471);
  error =
      clEnqueueWriteBuffer(command_queue, d_iS, 1, 0, mem_size_i, iS, 0, 0, 0);
  if (error != CL_SUCCESS)
    fatal_CL(error, 483);
  error =
      clEnqueueWriteBuffer(command_queue, d_jE, 1, 0, mem_size_j, jE, 0, 0, 0);
  if (error != CL_SUCCESS)
    fatal_CL(error, 495);
  error =
      clEnqueueWriteBuffer(command_queue, d_jW, 1, 0, mem_size_j, jW, 0, 0, 0);
  if (error != CL_SUCCESS)
    fatal_CL(error, 507);
  size_t local_work_size[1];
  local_work_size[0] = 128;
  int blocks_work_size;
  size_t global_work_size[1];
  blocks_x = Ne / (int)local_work_size[0];
  if (Ne % (int)local_work_size[0] != 0) {
    blocks_x = blocks_x + 1;
  }
  blocks_work_size = blocks_x;
  global_work_size[0] = blocks_work_size * local_work_size[0];
  printf("max # of workgroups = %d, # of threads/workgroup = %d (ensure that "
         "device can handle)\n",
         (int)(global_work_size[0] / local_work_size[0]),
         (int)local_work_size[0]);
  error = clSetKernelArg(extract_kernel, 0, sizeof(long), (void *)&Ne);
  if (error != CL_SUCCESS)
    fatal_CL(error, 546);
  error = clSetKernelArg(extract_kernel, 1, sizeof(cl_mem), (void *)&d_I);
  if (error != CL_SUCCESS)
    fatal_CL(error, 552);
  error =
      clEnqueueNDRangeKernel(command_queue, extract_kernel, 1, NULL,
                             global_work_size, local_work_size, 0, NULL, NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 568);
  error = clSetKernelArg(prepare_kernel, 0, sizeof(long), (void *)&Ne);
  if (error != CL_SUCCESS)
    fatal_CL(error, 595);
  error = clSetKernelArg(prepare_kernel, 1, sizeof(cl_mem), (void *)&d_I);
  if (error != CL_SUCCESS)
    fatal_CL(error, 601);
  error = clSetKernelArg(prepare_kernel, 2, sizeof(cl_mem), (void *)&d_sums);
  if (error != CL_SUCCESS)
    fatal_CL(error, 607);
  error = clSetKernelArg(prepare_kernel, 3, sizeof(cl_mem), (void *)&d_sums2);
  if (error != CL_SUCCESS)
    fatal_CL(error, 613);
  int blocks2_x;
  int blocks2_work_size;
  size_t global_work_size2[1];
  long no;
  int mul;
  int mem_size_single = sizeof(float) * 1;
  float total;
  float total2;
  float meanROI;
  float meanROI2;
  float varROI;
  float q0sqr;
  error = clSetKernelArg(reduce_kernel, 0, sizeof(long), (void *)&Ne);
  if (error != CL_SUCCESS)
    fatal_CL(error, 637);
  error = clSetKernelArg(reduce_kernel, 3, sizeof(cl_mem), (void *)&d_sums);
  if (error != CL_SUCCESS)
    fatal_CL(error, 643);
  error = clSetKernelArg(reduce_kernel, 4, sizeof(cl_mem), (void *)&d_sums2);
  if (error != CL_SUCCESS)
    fatal_CL(error, 649);
  error = clSetKernelArg(srad_kernel, 0, sizeof(float), (void *)&lambda);
  if (error != CL_SUCCESS)
    fatal_CL(error, 660);
  error = clSetKernelArg(srad_kernel, 1, sizeof(int), (void *)&Nr);
  if (error != CL_SUCCESS)
    fatal_CL(error, 666);
  error = clSetKernelArg(srad_kernel, 2, sizeof(int), (void *)&Nc);
  if (error != CL_SUCCESS)
    fatal_CL(error, 672);
  error = clSetKernelArg(srad_kernel, 3, sizeof(long), (void *)&Ne);
  if (error != CL_SUCCESS)
    fatal_CL(error, 678);
  error = clSetKernelArg(srad_kernel, 4, sizeof(cl_mem), (void *)&d_iN);
  if (error != CL_SUCCESS)
    fatal_CL(error, 684);
  error = clSetKernelArg(srad_kernel, 5, sizeof(cl_mem), (void *)&d_iS);
  if (error != CL_SUCCESS)
    fatal_CL(error, 690);
  error = clSetKernelArg(srad_kernel, 6, sizeof(cl_mem), (void *)&d_jE);
  if (error != CL_SUCCESS)
    fatal_CL(error, 696);
  error = clSetKernelArg(srad_kernel, 7, sizeof(cl_mem), (void *)&d_jW);
  if (error != CL_SUCCESS)
    fatal_CL(error, 702);
  error = clSetKernelArg(srad_kernel, 8, sizeof(cl_mem), (void *)&d_dN);
  if (error != CL_SUCCESS)
    fatal_CL(error, 708);
  error = clSetKernelArg(srad_kernel, 9, sizeof(cl_mem), (void *)&d_dS);
  if (error != CL_SUCCESS)
    fatal_CL(error, 714);
  error = clSetKernelArg(srad_kernel, 10, sizeof(cl_mem), (void *)&d_dW);
  if (error != CL_SUCCESS)
    fatal_CL(error, 720);
  error = clSetKernelArg(srad_kernel, 11, sizeof(cl_mem), (void *)&d_dE);
  if (error != CL_SUCCESS)
    fatal_CL(error, 726);
  error = clSetKernelArg(srad_kernel, 13, sizeof(cl_mem), (void *)&d_c);
  if (error != CL_SUCCESS)
    fatal_CL(error, 732);
  error = clSetKernelArg(srad_kernel, 14, sizeof(cl_mem), (void *)&d_I);
  if (error != CL_SUCCESS)
    fatal_CL(error, 738);
  error = clSetKernelArg(srad2_kernel, 0, sizeof(float), (void *)&lambda);
  if (error != CL_SUCCESS)
    fatal_CL(error, 749);
  error = clSetKernelArg(srad2_kernel, 1, sizeof(int), (void *)&Nr);
  if (error != CL_SUCCESS)
    fatal_CL(error, 755);
  error = clSetKernelArg(srad2_kernel, 2, sizeof(int), (void *)&Nc);
  if (error != CL_SUCCESS)
    fatal_CL(error, 761);
  error = clSetKernelArg(srad2_kernel, 3, sizeof(long), (void *)&Ne);
  if (error != CL_SUCCESS)
    fatal_CL(error, 767);
  error = clSetKernelArg(srad2_kernel, 4, sizeof(cl_mem), (void *)&d_iN);
  if (error != CL_SUCCESS)
    fatal_CL(error, 773);
  error = clSetKernelArg(srad2_kernel, 5, sizeof(cl_mem), (void *)&d_iS);
  if (error != CL_SUCCESS)
    fatal_CL(error, 779);
  error = clSetKernelArg(srad2_kernel, 6, sizeof(cl_mem), (void *)&d_jE);
  if (error != CL_SUCCESS)
    fatal_CL(error, 785);
  error = clSetKernelArg(srad2_kernel, 7, sizeof(cl_mem), (void *)&d_jW);
  if (error != CL_SUCCESS)
    fatal_CL(error, 791);
  error = clSetKernelArg(srad2_kernel, 8, sizeof(cl_mem), (void *)&d_dN);
  if (error != CL_SUCCESS)
    fatal_CL(error, 797);
  error = clSetKernelArg(srad2_kernel, 9, sizeof(cl_mem), (void *)&d_dS);
  if (error != CL_SUCCESS)
    fatal_CL(error, 803);
  error = clSetKernelArg(srad2_kernel, 10, sizeof(cl_mem), (void *)&d_dW);
  if (error != CL_SUCCESS)
    fatal_CL(error, 809);
  error = clSetKernelArg(srad2_kernel, 11, sizeof(cl_mem), (void *)&d_dE);
  if (error != CL_SUCCESS)
    fatal_CL(error, 815);
  error = clSetKernelArg(srad2_kernel, 12, sizeof(cl_mem), (void *)&d_c);
  if (error != CL_SUCCESS)
    fatal_CL(error, 821);
  error = clSetKernelArg(srad2_kernel, 13, sizeof(cl_mem), (void *)&d_I);
  if (error != CL_SUCCESS)
    fatal_CL(error, 827);
  printf("Iterations Progress: ");
  for (iter = 0; iter < niter; iter++) {
    printf("%d ", iter);
    fflush(NULL);
    error = clEnqueueNDRangeKernel(command_queue, prepare_kernel, 1, NULL,
                                   global_work_size, local_work_size, 0, NULL,
                                   NULL);
    if (error != CL_SUCCESS)
      fatal_CL(error, 860);
    blocks2_work_size = blocks_work_size;
    global_work_size2[0] = global_work_size[0];
    no = Ne;
    mul = 1;
    while (blocks2_work_size != 0) {
      error = clSetKernelArg(reduce_kernel, 1, sizeof(long), (void *)&no);
      if (error != CL_SUCCESS)
        fatal_CL(error, 886);
      error = clSetKernelArg(reduce_kernel, 2, sizeof(int), (void *)&mul);
      if (error != CL_SUCCESS)
        fatal_CL(error, 892);
      error = clSetKernelArg(reduce_kernel, 5, sizeof(int),
                             (void *)&blocks2_work_size);
      if (error != CL_SUCCESS)
        fatal_CL(error, 899);
      error = clEnqueueNDRangeKernel(command_queue, reduce_kernel, 1, NULL,
                                     global_work_size2, local_work_size, 0,
                                     NULL, NULL);
      if (error != CL_SUCCESS)
        fatal_CL(error, 912);
      no = blocks2_work_size;
      if (blocks2_work_size == 1) {
        blocks2_work_size = 0;
      } else {
        mul = mul * 128;
        blocks_x = blocks2_work_size / (int)local_work_size[0];
        if (blocks2_work_size % (int)local_work_size[0] != 0) {
          blocks_x = blocks_x + 1;
        }
        blocks2_work_size = blocks_x;
        global_work_size2[0] = blocks2_work_size * (int)local_work_size[0];
      }
    }
    error = clEnqueueReadBuffer(command_queue, d_sums, CL_TRUE, 0,
                                mem_size_single, &total, 0, NULL, NULL);
    if (error != CL_SUCCESS)
      fatal_CL(error, 947);
    error = clEnqueueReadBuffer(command_queue, d_sums2, CL_TRUE, 0,
                                mem_size_single, &total2, 0, NULL, NULL);
    if (error != CL_SUCCESS)
      fatal_CL(error, 959);
    meanROI = total / (float)(NeROI);
    meanROI2 = meanROI * meanROI;
    varROI = (total2 / (float)(NeROI)) - meanROI2;
    q0sqr = varROI / meanROI2;
    error = clSetKernelArg(srad_kernel, 12, sizeof(float), (void *)&q0sqr);
    if (error != CL_SUCCESS)
      fatal_CL(error, 980);
    error = clEnqueueNDRangeKernel(command_queue, srad_kernel, 1, NULL,
                                   global_work_size, local_work_size, 0, NULL,
                                   NULL);
    if (error != CL_SUCCESS)
      fatal_CL(error, 993);
    error = clEnqueueNDRangeKernel(command_queue, srad2_kernel, 1, NULL,
                                   global_work_size, local_work_size, 0, NULL,
                                   NULL);
    if (error != CL_SUCCESS)
      fatal_CL(error, 1015);
  }
  printf("\n");
  error = clSetKernelArg(compress_kernel, 0, sizeof(long), (void *)&Ne);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1043);
  error = clSetKernelArg(compress_kernel, 1, sizeof(cl_mem), (void *)&d_I);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1049);
  error =
      clEnqueueNDRangeKernel(command_queue, compress_kernel, 1, NULL,
                             global_work_size, local_work_size, 0, NULL, NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1065);
  error = clFinish(command_queue);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1073);
  error = clEnqueueReadBuffer(command_queue, d_I, CL_TRUE, 0, mem_size, image,
                              0, NULL, NULL);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1093);
  error = clReleaseKernel(extract_kernel);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1107);
  error = clReleaseKernel(prepare_kernel);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1110);
  error = clReleaseKernel(reduce_kernel);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1113);
  error = clReleaseKernel(srad_kernel);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1116);
  error = clReleaseKernel(srad2_kernel);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1119);
  error = clReleaseKernel(compress_kernel);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1122);
  error = clReleaseProgram(program);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1125);
  error = clReleaseMemObject(d_I);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1130);
  error = clReleaseMemObject(d_c);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1133);
  error = clReleaseMemObject(d_iN);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1137);
  error = clReleaseMemObject(d_iS);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1140);
  error = clReleaseMemObject(d_jE);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1143);
  error = clReleaseMemObject(d_jW);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1146);
  error = clReleaseMemObject(d_dN);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1150);
  error = clReleaseMemObject(d_dS);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1153);
  error = clReleaseMemObject(d_dE);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1156);
  error = clReleaseMemObject(d_dW);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1159);
  error = clReleaseMemObject(d_sums);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1163);
  error = clReleaseMemObject(d_sums2);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1166);
  error = clFlush(command_queue);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1171);
  error = clReleaseCommandQueue(command_queue);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1174);
  error = clReleaseContext(context);
  if (error != CL_SUCCESS)
    fatal_CL(error, 1177);
}


x86 assembly (clang, -O0):
<kernel_gpu_opencl_wrapper>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xor    %edi,%edi
xor    %eax,%eax
mov    %eax,%esi
lea    -0x34(%rbp),%rdx
call   1100 <clGetPlatformIDs@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4c5b(%rip),%rcx
cmp    (%rcx),%rax
je     1364 <kernel_gpu_opencl_wrapper+0x74>
mov    -0x30(%rbp),%rdi
mov    $0x52,%esi
call   11e0 <fatal_CL@plt>
movslq -0x34(%rbp),%rdi
shl    $0x2,%rdi
call   1160 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x34(%rbp),%edi
mov    -0x40(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edx
call   1100 <clGetPlatformIDs@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4c14(%rip),%rcx
cmp    (%rcx),%rax
je     13ab <kernel_gpu_opencl_wrapper+0xbb>
mov    -0x30(%rbp),%rdi
mov    $0x5a,%esi
call   11e0 <fatal_CL@plt>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edi
mov    0x4bda(%rip),%rax
mov    (%rax),%esi
lea    -0xb0(%rbp),%rcx
mov    $0x64,%edx
xor    %eax,%eax
mov    %eax,%r8d
call   1130 <clGetPlatformInfo@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4bc3(%rip),%rcx
cmp    (%rcx),%rax
je     13fc <kernel_gpu_opencl_wrapper+0x10c>
mov    -0x30(%rbp),%rdi
mov    $0x67,%esi
call   11e0 <fatal_CL@plt>
lea    -0xb0(%rbp),%rsi
lea    0x2bf6(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
mov    0x4b98(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movl   $0x0,-0xb4(%rbp)
lea    -0xbc(%rbp),%rdi
mov    0x4b87(%rip),%rax
mov    (%rax),%esi
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
mov    %rcx,%rdx
call   11a0 <clCreateContextFromType@plt>
mov    %eax,-0xc0(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4b44(%rip),%rcx
cmp    (%rcx),%rax
je     147b <kernel_gpu_opencl_wrapper+0x18b>
mov    -0x30(%rbp),%rdi
mov    $0x7b,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x4b50(%rip),%rax
mov    (%rax),%esi
xor    %eax,%eax
mov    %eax,%ecx
lea    -0xc8(%rbp),%r8
mov    %rcx,%rdx
call   1050 <clGetContextInfo@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4afc(%rip),%rcx
cmp    (%rcx),%rax
je     14c3 <kernel_gpu_opencl_wrapper+0x1d3>
mov    -0x30(%rbp),%rdi
mov    $0x89,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc8(%rbp),%rdi
call   1160 <malloc@plt>
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%edi
mov    0x4af5(%rip),%rax
mov    (%rax),%esi
mov    -0xc8(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
xor    %eax,%eax
mov    %eax,%r8d
call   1050 <clGetContextInfo@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4a9c(%rip),%rcx
cmp    (%rcx),%rax
je     1523 <kernel_gpu_opencl_wrapper+0x233>
mov    -0x30(%rbp),%rdi
mov    $0x93,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%edi
mov    0x4a79(%rip),%rax
mov    (%rax),%esi
lea    -0xb0(%rbp),%rcx
mov    $0x64,%edx
xor    %eax,%eax
mov    %eax,%r8d
call   10c0 <clGetDeviceInfo@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4a42(%rip),%rcx
cmp    (%rcx),%rax
je     157d <kernel_gpu_opencl_wrapper+0x28d>
mov    -0x30(%rbp),%rdi
mov    $0xa0,%esi
call   11e0 <fatal_CL@plt>
lea    -0xb0(%rbp),%rsi
lea    0x2a83(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
mov    -0xc0(%rbp),%edi
mov    -0xd4(%rbp),%esi
xor    %edx,%edx
lea    -0x30(%rbp),%rcx
call   10f0 <clCreateCommandQueue@plt>
mov    %eax,-0xd8(%rbp)
mov    -0x30(%rbp),%rax
mov    0x49ee(%rip),%rcx
cmp    (%rcx),%rax
je     15d1 <kernel_gpu_opencl_wrapper+0x2e1>
mov    -0x30(%rbp),%rdi
mov    $0xae,%esi
call   11e0 <fatal_CL@plt>
lea    0x2a42(%rip),%rdi
call   1030 <load_kernel_source@plt>
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rdi
call   10d0 <strlen@plt>
mov    %rax,-0xe8(%rbp)
mov    -0xc0(%rbp),%edi
mov    $0x1,%esi
lea    -0xe0(%rbp),%rdx
lea    -0xe8(%rbp),%rcx
lea    -0x30(%rbp),%r8
call   1070 <clCreateProgramWithSource@plt>
mov    %eax,-0xec(%rbp)
mov    -0x30(%rbp),%rax
mov    0x497e(%rip),%rcx
cmp    (%rcx),%rax
je     1641 <kernel_gpu_opencl_wrapper+0x351>
mov    -0x30(%rbp),%rdi
mov    $0xbf,%esi
call   11e0 <fatal_CL@plt>
lea    -0x190(%rbp),%rdi
lea    0x29e9(%rip),%rsi
call   11d0 <sprintf@plt>
mov    -0xec(%rbp),%edi
lea    -0x190(%rbp),%rcx
mov    $0x1,%esi
lea    -0xd4(%rbp),%rdx
xor    %eax,%eax
mov    %eax,%r9d
mov    %r9,%r8
call   1040 <clBuildProgram@plt>
mov    %rax,-0x30(%rbp)
lea    0x4acb(%rip),%rdi
xor    %esi,%esi
mov    $0x10000,%edx
call   1120 <memset@plt>
mov    -0xec(%rbp),%edi
mov    -0xd4(%rbp),%esi
mov    0x492c(%rip),%rax
mov    (%rax),%edx
mov    $0xffff,%ecx
lea    0x4a9e(%rip),%r8
xor    %eax,%eax
mov    %eax,%r9d
call   1140 <clGetProgramBuildInfo@plt>
lea    0x2979(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
lea    0x4a7f(%rip),%rdi
lea    0x2986(%rip),%rsi
call   1200 <strstr@plt>
cmp    $0x0,%rax
jne    1704 <kernel_gpu_opencl_wrapper+0x414>
lea    0x4a62(%rip),%rdi
lea    0x2972(%rip),%rsi
call   1200 <strstr@plt>
cmp    $0x0,%rax
je     1719 <kernel_gpu_opencl_wrapper+0x429>
lea    0x2963(%rip),%rdi
lea    0x4a3e(%rip),%rsi
mov    $0x0,%al
call   1110 <printf@plt>
lea    0x295c(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
mov    -0x30(%rbp),%rax
mov    0x4876(%rip),%rcx
cmp    (%rcx),%rax
je     1749 <kernel_gpu_opencl_wrapper+0x459>
mov    -0x30(%rbp),%rdi
mov    $0xe3,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
lea    0x2948(%rip),%rsi
lea    -0x30(%rbp),%rdx
call   11c0 <clCreateKernel@plt>
mov    %eax,-0x194(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4838(%rip),%rcx
cmp    (%rcx),%rax
je     1787 <kernel_gpu_opencl_wrapper+0x497>
mov    -0x30(%rbp),%rdi
mov    $0xef,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
lea    0x2919(%rip),%rsi
lea    -0x30(%rbp),%rdx
call   11c0 <clCreateKernel@plt>
mov    %eax,-0x198(%rbp)
mov    -0x30(%rbp),%rax
mov    0x47fa(%rip),%rcx
cmp    (%rcx),%rax
je     17c5 <kernel_gpu_opencl_wrapper+0x4d5>
mov    -0x30(%rbp),%rdi
mov    $0xf7,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
lea    0x28ea(%rip),%rsi
lea    -0x30(%rbp),%rdx
call   11c0 <clCreateKernel@plt>
mov    %eax,-0x19c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x47bc(%rip),%rcx
cmp    (%rcx),%rax
je     1803 <kernel_gpu_opencl_wrapper+0x513>
mov    -0x30(%rbp),%rdi
mov    $0xff,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
lea    0x28ba(%rip),%rsi
lea    -0x30(%rbp),%rdx
call   11c0 <clCreateKernel@plt>
mov    %eax,-0x1a0(%rbp)
mov    -0x30(%rbp),%rax
mov    0x477e(%rip),%rcx
cmp    (%rcx),%rax
je     1841 <kernel_gpu_opencl_wrapper+0x551>
mov    -0x30(%rbp),%rdi
mov    $0x107,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
lea    0x2888(%rip),%rsi
lea    -0x30(%rbp),%rdx
call   11c0 <clCreateKernel@plt>
mov    %eax,-0x1a4(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4740(%rip),%rcx
cmp    (%rcx),%rax
je     187f <kernel_gpu_opencl_wrapper+0x58f>
mov    -0x30(%rbp),%rdi
mov    $0x10f,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
lea    0x2857(%rip),%rsi
lea    -0x30(%rbp),%rdx
call   11c0 <clCreateKernel@plt>
mov    %eax,-0x1a8(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4702(%rip),%rcx
cmp    (%rcx),%rax
je     18bd <kernel_gpu_opencl_wrapper+0x5cd>
mov    -0x30(%rbp),%rdi
mov    $0x117,%esi
call   11e0 <fatal_CL@plt>
mov    -0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,-0x1b0(%rbp)
mov    -0xc0(%rbp),%edi
mov    0x4708(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1b4(%rbp)
mov    -0x30(%rbp),%rax
mov    0x46aa(%rip),%rcx
cmp    (%rcx),%rax
je     1915 <kernel_gpu_opencl_wrapper+0x625>
mov    -0x30(%rbp),%rdi
mov    $0x13c,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x46be(%rip),%rax
mov    (%rax),%esi
mov    0x38(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1b8(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4663(%rip),%rcx
cmp    (%rcx),%rax
je     195c <kernel_gpu_opencl_wrapper+0x66c>
mov    -0x30(%rbp),%rdi
mov    $0x149,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x4677(%rip),%rax
mov    (%rax),%esi
mov    0x38(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1bc(%rbp)
mov    -0x30(%rbp),%rax
mov    0x461c(%rip),%rcx
cmp    (%rcx),%rax
je     19a3 <kernel_gpu_opencl_wrapper+0x6b3>
mov    -0x30(%rbp),%rdi
mov    $0x152,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x4630(%rip),%rax
mov    (%rax),%esi
mov    0x40(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1c0(%rbp)
mov    -0x30(%rbp),%rax
mov    0x45d5(%rip),%rcx
cmp    (%rcx),%rax
je     19ea <kernel_gpu_opencl_wrapper+0x6fa>
mov    -0x30(%rbp),%rdi
mov    $0x15b,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x45e9(%rip),%rax
mov    (%rax),%esi
mov    0x40(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1c4(%rbp)
mov    -0x30(%rbp),%rax
mov    0x458e(%rip),%rcx
cmp    (%rcx),%rax
je     1a31 <kernel_gpu_opencl_wrapper+0x741>
mov    -0x30(%rbp),%rdi
mov    $0x164,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x45a2(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1c8(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4544(%rip),%rcx
cmp    (%rcx),%rax
je     1a7b <kernel_gpu_opencl_wrapper+0x78b>
mov    -0x30(%rbp),%rdi
mov    $0x171,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x4558(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1cc(%rbp)
mov    -0x30(%rbp),%rax
mov    0x44fa(%rip),%rcx
cmp    (%rcx),%rax
je     1ac5 <kernel_gpu_opencl_wrapper+0x7d5>
mov    -0x30(%rbp),%rdi
mov    $0x17a,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x450e(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1d0(%rbp)
mov    -0x30(%rbp),%rax
mov    0x44b0(%rip),%rcx
cmp    (%rcx),%rax
je     1b0f <kernel_gpu_opencl_wrapper+0x81f>
mov    -0x30(%rbp),%rdi
mov    $0x183,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x44c4(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1d4(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4466(%rip),%rcx
cmp    (%rcx),%rax
je     1b59 <kernel_gpu_opencl_wrapper+0x869>
mov    -0x30(%rbp),%rdi
mov    $0x18c,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x447a(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1d8(%rbp)
mov    -0x30(%rbp),%rax
mov    0x441c(%rip),%rcx
cmp    (%rcx),%rax
je     1ba3 <kernel_gpu_opencl_wrapper+0x8b3>
mov    -0x30(%rbp),%rdi
mov    $0x199,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x4430(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1dc(%rbp)
mov    -0x30(%rbp),%rax
mov    0x43d2(%rip),%rcx
cmp    (%rcx),%rax
je     1bed <kernel_gpu_opencl_wrapper+0x8fd>
mov    -0x30(%rbp),%rdi
mov    $0x1a6,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
mov    0x43e6(%rip),%rax
mov    (%rax),%esi
mov    -0x1b0(%rbp),%edx
xor    %eax,%eax
mov    %eax,%ecx
lea    -0x30(%rbp),%r8
call   10a0 <clCreateBuffer@plt>
mov    %eax,-0x1e0(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4388(%rip),%rcx
cmp    (%rcx),%rax
je     1c37 <kernel_gpu_opencl_wrapper+0x947>
mov    -0x30(%rbp),%rdi
mov    $0x1af,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1b4(%rbp),%esi
mov    -0x1b0(%rbp),%r8d
mov    -0x8(%rbp),%r9
mov    $0x1,%edx
xor    %ecx,%ecx
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1210 <clEnqueueWriteBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4326(%rip),%rcx
cmp    (%rcx),%rax
je     1c99 <kernel_gpu_opencl_wrapper+0x9a9>
mov    -0x30(%rbp),%rdi
mov    $0x1c7,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1b8(%rbp),%esi
mov    0x38(%rbp),%r8d
mov    0x10(%rbp),%r9
mov    $0x1,%edx
xor    %ecx,%ecx
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1210 <clEnqueueWriteBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x42c7(%rip),%rcx
cmp    (%rcx),%rax
je     1cf8 <kernel_gpu_opencl_wrapper+0xa08>
mov    -0x30(%rbp),%rdi
mov    $0x1d7,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1bc(%rbp),%esi
mov    0x38(%rbp),%r8d
mov    0x18(%rbp),%r9
mov    $0x1,%edx
xor    %ecx,%ecx
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1210 <clEnqueueWriteBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4268(%rip),%rcx
cmp    (%rcx),%rax
je     1d57 <kernel_gpu_opencl_wrapper+0xa67>
mov    -0x30(%rbp),%rdi
mov    $0x1e3,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1c0(%rbp),%esi
mov    0x40(%rbp),%r8d
mov    0x20(%rbp),%r9
mov    $0x1,%edx
xor    %ecx,%ecx
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1210 <clEnqueueWriteBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4209(%rip),%rcx
cmp    (%rcx),%rax
je     1db6 <kernel_gpu_opencl_wrapper+0xac6>
mov    -0x30(%rbp),%rdi
mov    $0x1ef,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1c4(%rbp),%esi
mov    0x40(%rbp),%r8d
mov    0x28(%rbp),%r9
mov    $0x1,%edx
xor    %ecx,%ecx
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1210 <clEnqueueWriteBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x41aa(%rip),%rcx
cmp    (%rcx),%rax
je     1e15 <kernel_gpu_opencl_wrapper+0xb25>
mov    -0x30(%rbp),%rdi
mov    $0x1fb,%esi
call   11e0 <fatal_CL@plt>
movq   $0x80,-0x1e8(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq %ecx,%rcx
cqto
idiv   %rcx
mov    %eax,-0x1ac(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
je     1e65 <kernel_gpu_opencl_wrapper+0xb75>
mov    -0x1ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x1ac(%rbp),%eax
mov    %eax,-0x1ec(%rbp)
movslq -0x1ec(%rbp),%rax
imul   -0x1e8(%rbp),%rax
ff
mov    %rax,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x1e8(%rbp)
mov    %eax,%esi
mov    -0x1e8(%rbp),%rax
mov    %eax,%edx
lea    0x2248(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
mov    -0x194(%rbp),%edi
lea    -0x18(%rbp),%rcx
xor    %esi,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x40d1(%rip),%rcx
cmp    (%rcx),%rax
je     1eee <kernel_gpu_opencl_wrapper+0xbfe>
mov    -0x30(%rbp),%rdi
mov    $0x222,%esi
call   11e0 <fatal_CL@plt>
mov    -0x194(%rbp),%edi
lea    -0x1b4(%rbp),%rcx
mov    $0x1,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x408f(%rip),%rcx
cmp    (%rcx),%rax
je     1f30 <kernel_gpu_opencl_wrapper+0xc40>
mov    -0x30(%rbp),%rdi
mov    $0x228,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x194(%rbp),%esi
lea    -0x1f8(%rbp),%r8
lea    -0x1e8(%rbp),%r9
mov    $0x1,%edx
xor    %eax,%eax
mov    %eax,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   10e0 <clEnqueueNDRangeKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4026(%rip),%rcx
cmp    (%rcx),%rax
je     1f99 <kernel_gpu_opencl_wrapper+0xca9>
mov    -0x30(%rbp),%rdi
mov    $0x238,%esi
call   11e0 <fatal_CL@plt>
mov    -0x198(%rbp),%edi
lea    -0x18(%rbp),%rcx
xor    %esi,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3fea(%rip),%rcx
cmp    (%rcx),%rax
je     1fd5 <kernel_gpu_opencl_wrapper+0xce5>
mov    -0x30(%rbp),%rdi
mov    $0x253,%esi
call   11e0 <fatal_CL@plt>
mov    -0x198(%rbp),%edi
lea    -0x1b4(%rbp),%rcx
mov    $0x1,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3fa8(%rip),%rcx
cmp    (%rcx),%rax
je     2017 <kernel_gpu_opencl_wrapper+0xd27>
mov    -0x30(%rbp),%rdi
mov    $0x259,%esi
call   11e0 <fatal_CL@plt>
mov    -0x198(%rbp),%edi
lea    -0x1dc(%rbp),%rcx
mov    $0x2,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3f66(%rip),%rcx
cmp    (%rcx),%rax
je     2059 <kernel_gpu_opencl_wrapper+0xd69>
mov    -0x30(%rbp),%rdi
mov    $0x25f,%esi
call   11e0 <fatal_CL@plt>
mov    -0x198(%rbp),%edi
lea    -0x1e0(%rbp),%rcx
mov    $0x3,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3f24(%rip),%rcx
cmp    (%rcx),%rax
je     209b <kernel_gpu_opencl_wrapper+0xdab>
mov    -0x30(%rbp),%rdi
mov    $0x265,%esi
call   11e0 <fatal_CL@plt>
movl   $0x4,-0x218(%rbp)
mov    -0x19c(%rbp),%edi
lea    -0x18(%rbp),%rcx
xor    %esi,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3ede(%rip),%rcx
cmp    (%rcx),%rax
je     20e1 <kernel_gpu_opencl_wrapper+0xdf1>
mov    -0x30(%rbp),%rdi
mov    $0x27d,%esi
call   11e0 <fatal_CL@plt>
mov    -0x19c(%rbp),%edi
lea    -0x1dc(%rbp),%rcx
mov    $0x3,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3e9c(%rip),%rcx
cmp    (%rcx),%rax
je     2123 <kernel_gpu_opencl_wrapper+0xe33>
mov    -0x30(%rbp),%rdi
mov    $0x283,%esi
call   11e0 <fatal_CL@plt>
mov    -0x19c(%rbp),%edi
lea    -0x1e0(%rbp),%rcx
mov    $0x4,%edx
mov    %edx,%esi
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3e5d(%rip),%rcx
cmp    (%rcx),%rax
je     2162 <kernel_gpu_opencl_wrapper+0xe72>
mov    -0x30(%rbp),%rdi
mov    $0x289,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x20(%rbp),%rcx
xor    %esi,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3e21(%rip),%rcx
cmp    (%rcx),%rax
je     219e <kernel_gpu_opencl_wrapper+0xeae>
mov    -0x30(%rbp),%rdi
mov    $0x294,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0xc(%rbp),%rcx
mov    $0x1,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3de2(%rip),%rcx
cmp    (%rcx),%rax
je     21dd <kernel_gpu_opencl_wrapper+0xeed>
mov    -0x30(%rbp),%rdi
mov    $0x29a,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x10(%rbp),%rcx
mov    $0x2,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3da3(%rip),%rcx
cmp    (%rcx),%rax
je     221c <kernel_gpu_opencl_wrapper+0xf2c>
mov    -0x30(%rbp),%rdi
mov    $0x2a0,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x18(%rbp),%rcx
mov    $0x3,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3d64(%rip),%rcx
cmp    (%rcx),%rax
je     225b <kernel_gpu_opencl_wrapper+0xf6b>
mov    -0x30(%rbp),%rdi
mov    $0x2a6,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1b8(%rbp),%rcx
mov    $0x4,%edx
mov    %edx,%esi
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3d25(%rip),%rcx
cmp    (%rcx),%rax
je     229a <kernel_gpu_opencl_wrapper+0xfaa>
mov    -0x30(%rbp),%rdi
mov    $0x2ac,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1bc(%rbp),%rcx
mov    $0x5,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3ce3(%rip),%rcx
cmp    (%rcx),%rax
je     22dc <kernel_gpu_opencl_wrapper+0xfec>
mov    -0x30(%rbp),%rdi
mov    $0x2b2,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1c0(%rbp),%rcx
mov    $0x6,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3ca1(%rip),%rcx
cmp    (%rcx),%rax
je     231e <kernel_gpu_opencl_wrapper+0x102e>
mov    -0x30(%rbp),%rdi
mov    $0x2b8,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1c4(%rbp),%rcx
mov    $0x7,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3c5f(%rip),%rcx
cmp    (%rcx),%rax
je     2360 <kernel_gpu_opencl_wrapper+0x1070>
mov    -0x30(%rbp),%rdi
mov    $0x2be,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1c8(%rbp),%rcx
mov    $0x8,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3c1d(%rip),%rcx
cmp    (%rcx),%rax
je     23a2 <kernel_gpu_opencl_wrapper+0x10b2>
mov    -0x30(%rbp),%rdi
mov    $0x2c4,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1cc(%rbp),%rcx
mov    $0x9,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3bdb(%rip),%rcx
cmp    (%rcx),%rax
je     23e4 <kernel_gpu_opencl_wrapper+0x10f4>
mov    -0x30(%rbp),%rdi
mov    $0x2ca,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1d0(%rbp),%rcx
mov    $0xa,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3b99(%rip),%rcx
cmp    (%rcx),%rax
je     2426 <kernel_gpu_opencl_wrapper+0x1136>
mov    -0x30(%rbp),%rdi
mov    $0x2d0,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1d4(%rbp),%rcx
mov    $0xb,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3b57(%rip),%rcx
cmp    (%rcx),%rax
je     2468 <kernel_gpu_opencl_wrapper+0x1178>
mov    -0x30(%rbp),%rdi
mov    $0x2d6,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1d8(%rbp),%rcx
mov    $0xd,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3b15(%rip),%rcx
cmp    (%rcx),%rax
je     24aa <kernel_gpu_opencl_wrapper+0x11ba>
mov    -0x30(%rbp),%rdi
mov    $0x2dc,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
lea    -0x1b4(%rbp),%rcx
mov    $0xe,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3ad3(%rip),%rcx
cmp    (%rcx),%rax
je     24ec <kernel_gpu_opencl_wrapper+0x11fc>
mov    -0x30(%rbp),%rdi
mov    $0x2e2,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x20(%rbp),%rcx
xor    %esi,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3a97(%rip),%rcx
cmp    (%rcx),%rax
je     2528 <kernel_gpu_opencl_wrapper+0x1238>
mov    -0x30(%rbp),%rdi
mov    $0x2ed,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0xc(%rbp),%rcx
mov    $0x1,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3a58(%rip),%rcx
cmp    (%rcx),%rax
je     2567 <kernel_gpu_opencl_wrapper+0x1277>
mov    -0x30(%rbp),%rdi
mov    $0x2f3,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x10(%rbp),%rcx
mov    $0x2,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3a19(%rip),%rcx
cmp    (%rcx),%rax
je     25a6 <kernel_gpu_opencl_wrapper+0x12b6>
mov    -0x30(%rbp),%rdi
mov    $0x2f9,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x18(%rbp),%rcx
mov    $0x3,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x39da(%rip),%rcx
cmp    (%rcx),%rax
je     25e5 <kernel_gpu_opencl_wrapper+0x12f5>
mov    -0x30(%rbp),%rdi
mov    $0x2ff,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1b8(%rbp),%rcx
mov    $0x4,%edx
mov    %edx,%esi
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x399b(%rip),%rcx
cmp    (%rcx),%rax
je     2624 <kernel_gpu_opencl_wrapper+0x1334>
mov    -0x30(%rbp),%rdi
mov    $0x305,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1bc(%rbp),%rcx
mov    $0x5,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3959(%rip),%rcx
cmp    (%rcx),%rax
je     2666 <kernel_gpu_opencl_wrapper+0x1376>
mov    -0x30(%rbp),%rdi
mov    $0x30b,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1c0(%rbp),%rcx
mov    $0x6,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3917(%rip),%rcx
cmp    (%rcx),%rax
je     26a8 <kernel_gpu_opencl_wrapper+0x13b8>
mov    -0x30(%rbp),%rdi
mov    $0x311,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1c4(%rbp),%rcx
mov    $0x7,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x38d5(%rip),%rcx
cmp    (%rcx),%rax
je     26ea <kernel_gpu_opencl_wrapper+0x13fa>
mov    -0x30(%rbp),%rdi
mov    $0x317,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1c8(%rbp),%rcx
mov    $0x8,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3893(%rip),%rcx
cmp    (%rcx),%rax
je     272c <kernel_gpu_opencl_wrapper+0x143c>
mov    -0x30(%rbp),%rdi
mov    $0x31d,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1cc(%rbp),%rcx
mov    $0x9,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3851(%rip),%rcx
cmp    (%rcx),%rax
je     276e <kernel_gpu_opencl_wrapper+0x147e>
mov    -0x30(%rbp),%rdi
mov    $0x323,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1d0(%rbp),%rcx
mov    $0xa,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x380f(%rip),%rcx
cmp    (%rcx),%rax
je     27b0 <kernel_gpu_opencl_wrapper+0x14c0>
mov    -0x30(%rbp),%rdi
mov    $0x329,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1d4(%rbp),%rcx
mov    $0xb,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x37cd(%rip),%rcx
cmp    (%rcx),%rax
je     27f2 <kernel_gpu_opencl_wrapper+0x1502>
mov    -0x30(%rbp),%rdi
mov    $0x32f,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1d8(%rbp),%rcx
mov    $0xc,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x378b(%rip),%rcx
cmp    (%rcx),%rax
je     2834 <kernel_gpu_opencl_wrapper+0x1544>
mov    -0x30(%rbp),%rdi
mov    $0x335,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
lea    -0x1b4(%rbp),%rcx
mov    $0xd,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3749(%rip),%rcx
cmp    (%rcx),%rax
je     2876 <kernel_gpu_opencl_wrapper+0x1586>
mov    -0x30(%rbp),%rdi
mov    $0x33b,%esi
call   11e0 <fatal_CL@plt>
lea    0x18cd(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
movl   $0x0,0x30(%rbp)
mov    0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2d8f <kernel_gpu_opencl_wrapper+0x1a9f>
mov    0x30(%rbp),%esi
lea    0x18bf(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
xor    %eax,%eax
mov    %eax,%edi
call   1170 <fflush@plt>
mov    -0xd8(%rbp),%edi
mov    -0x198(%rbp),%esi
lea    -0x1f8(%rbp),%r8
lea    -0x1e8(%rbp),%r9
mov    $0x1,%edx
xor    %eax,%eax
mov    %eax,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   10e0 <clEnqueueNDRangeKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x36a5(%rip),%rcx
cmp    (%rcx),%rax
je     291a <kernel_gpu_opencl_wrapper+0x162a>
mov    -0x30(%rbp),%rdi
mov    $0x35c,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1ec(%rbp),%eax
mov    %eax,-0x200(%rbp)
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x210(%rbp)
movl   $0x1,-0x214(%rbp)
cmpl   $0x0,-0x200(%rbp)
je     2b26 <kernel_gpu_opencl_wrapper+0x1836>
mov    -0x19c(%rbp),%edi
lea    -0x210(%rbp),%rcx
mov    $0x1,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3627(%rip),%rcx
cmp    (%rcx),%rax
je     2998 <kernel_gpu_opencl_wrapper+0x16a8>
mov    -0x30(%rbp),%rdi
mov    $0x376,%esi
call   11e0 <fatal_CL@plt>
mov    -0x19c(%rbp),%edi
lea    -0x214(%rbp),%rcx
mov    $0x2,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x35e5(%rip),%rcx
cmp    (%rcx),%rax
je     29da <kernel_gpu_opencl_wrapper+0x16ea>
mov    -0x30(%rbp),%rdi
mov    $0x37c,%esi
call   11e0 <fatal_CL@plt>
mov    -0x19c(%rbp),%edi
lea    -0x200(%rbp),%rcx
mov    $0x5,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x35a3(%rip),%rcx
cmp    (%rcx),%rax
je     2a1c <kernel_gpu_opencl_wrapper+0x172c>
mov    -0x30(%rbp),%rdi
mov    $0x383,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x19c(%rbp),%esi
lea    -0x208(%rbp),%r8
lea    -0x1e8(%rbp),%r9
mov    $0x1,%edx
xor    %eax,%eax
mov    %eax,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   10e0 <clEnqueueNDRangeKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x353a(%rip),%rcx
cmp    (%rcx),%rax
je     2a85 <kernel_gpu_opencl_wrapper+0x1795>
mov    -0x30(%rbp),%rdi
mov    $0x390,%esi
call   11e0 <fatal_CL@plt>
movslq -0x200(%rbp),%rax
mov    %rax,-0x210(%rbp)
cmpl   $0x1,-0x200(%rbp)
jne    2aaf <kernel_gpu_opencl_wrapper+0x17bf>
movl   $0x0,-0x200(%rbp)
jmp    2b21 <kernel_gpu_opencl_wrapper+0x1831>
mov    -0x214(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0x214(%rbp)
mov    -0x200(%rbp),%eax
mov    -0x1e8(%rbp),%rcx
cltd
idiv   %ecx
mov    %eax,-0x1ac(%rbp)
mov    -0x200(%rbp),%eax
mov    -0x1e8(%rbp),%rcx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     2afc <kernel_gpu_opencl_wrapper+0x180c>
mov    -0x1ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x1ac(%rbp),%eax
mov    %eax,-0x200(%rbp)
mov    -0x200(%rbp),%eax
mov    -0x1e8(%rbp),%rcx
imul   %ecx,%eax
cltq
mov    %rax,-0x208(%rbp)
jmp    2949 <kernel_gpu_opencl_wrapper+0x1659>
mov    -0xd8(%rbp),%edi
mov    -0x1dc(%rbp),%esi
mov    0x34af(%rip),%rax
mov    (%rax),%edx
mov    -0x218(%rbp),%r8d
xor    %ecx,%ecx
lea    -0x21c(%rbp),%r9
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   1180 <clEnqueueReadBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x342e(%rip),%rcx
cmp    (%rcx),%rax
je     2b91 <kernel_gpu_opencl_wrapper+0x18a1>
mov    -0x30(%rbp),%rdi
mov    $0x3b3,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1e0(%rbp),%esi
mov    0x3444(%rip),%rax
mov    (%rax),%edx
mov    -0x218(%rbp),%r8d
xor    %ecx,%ecx
lea    -0x220(%rbp),%r9
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   1180 <clEnqueueReadBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x33c3(%rip),%rcx
cmp    (%rcx),%rax
je     2bfc <kernel_gpu_opencl_wrapper+0x190c>
mov    -0x30(%rbp),%rdi
mov    $0x3bf,%esi
call   11e0 <fatal_CL@plt>
movss  -0x21c(%rbp),%xmm0
ff
cvtsi2ssq -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x224(%rbp)
ff
movss  -0x224(%rbp),%xmm0
ff
mulss  -0x224(%rbp),%xmm0
ff
movss  %xmm0,-0x228(%rbp)
ff
movss  -0x220(%rbp),%xmm0
ff
cvtsi2ssq -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
subss  -0x228(%rbp),%xmm0
ff
movss  %xmm0,-0x22c(%rbp)
ff
movss  -0x22c(%rbp),%xmm0
ff
divss  -0x228(%rbp),%xmm0
ff
movss  %xmm0,-0x230(%rbp)
ff
mov    -0x1a0(%rbp),%edi
lea    -0x230(%rbp),%rcx
mov    $0xc,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3315(%rip),%rcx
cmp    (%rcx),%rax
je     2caa <kernel_gpu_opencl_wrapper+0x19ba>
mov    -0x30(%rbp),%rdi
mov    $0x3d4,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1a0(%rbp),%esi
lea    -0x1f8(%rbp),%r8
lea    -0x1e8(%rbp),%r9
mov    $0x1,%edx
xor    %eax,%eax
mov    %eax,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   10e0 <clEnqueueNDRangeKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x32ac(%rip),%rcx
cmp    (%rcx),%rax
je     2d13 <kernel_gpu_opencl_wrapper+0x1a23>
mov    -0x30(%rbp),%rdi
mov    $0x3e1,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1a4(%rbp),%esi
lea    -0x1f8(%rbp),%r8
lea    -0x1e8(%rbp),%r9
mov    $0x1,%edx
xor    %eax,%eax
mov    %eax,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   10e0 <clEnqueueNDRangeKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3243(%rip),%rcx
cmp    (%rcx),%rax
je     2d7c <kernel_gpu_opencl_wrapper+0x1a8c>
mov    -0x30(%rbp),%rdi
mov    $0x3f7,%esi
call   11e0 <fatal_CL@plt>
jmp    2d81 <kernel_gpu_opencl_wrapper+0x1a91>
mov    0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,0x30(%rbp)
jmp    288b <kernel_gpu_opencl_wrapper+0x159b>
lea    0x13b2(%rip),%rdi
mov    $0x0,%al
call   1110 <printf@plt>
mov    -0x1a8(%rbp),%edi
lea    -0x18(%rbp),%rcx
xor    %esi,%esi
mov    $0x8,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x31e6(%rip),%rcx
cmp    (%rcx),%rax
je     2dd9 <kernel_gpu_opencl_wrapper+0x1ae9>
mov    -0x30(%rbp),%rdi
mov    $0x413,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a8(%rbp),%edi
lea    -0x1b4(%rbp),%rcx
mov    $0x1,%esi
mov    $0x4,%edx
call   11f0 <clSetKernelArg@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x31a4(%rip),%rcx
cmp    (%rcx),%rax
je     2e1b <kernel_gpu_opencl_wrapper+0x1b2b>
mov    -0x30(%rbp),%rdi
mov    $0x419,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1a8(%rbp),%esi
lea    -0x1f8(%rbp),%r8
lea    -0x1e8(%rbp),%r9
mov    $0x1,%edx
xor    %eax,%eax
mov    %eax,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   10e0 <clEnqueueNDRangeKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x313b(%rip),%rcx
cmp    (%rcx),%rax
je     2e84 <kernel_gpu_opencl_wrapper+0x1b94>
mov    -0x30(%rbp),%rdi
mov    $0x429,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
call   1060 <clFinish@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x310a(%rip),%rcx
cmp    (%rcx),%rax
je     2eb5 <kernel_gpu_opencl_wrapper+0x1bc5>
mov    -0x30(%rbp),%rdi
mov    $0x431,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
mov    -0x1b4(%rbp),%esi
mov    0x3120(%rip),%rax
mov    (%rax),%edx
mov    -0x1b0(%rbp),%r8d
mov    -0x8(%rbp),%r9
xor    %ecx,%ecx
xor    %eax,%eax
movl   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
call   1180 <clEnqueueReadBuffer@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x30a2(%rip),%rcx
cmp    (%rcx),%rax
je     2f1d <kernel_gpu_opencl_wrapper+0x1c2d>
mov    -0x30(%rbp),%rdi
mov    $0x445,%esi
call   11e0 <fatal_CL@plt>
mov    -0x194(%rbp),%edi
call   1080 <clReleaseKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3071(%rip),%rcx
cmp    (%rcx),%rax
je     2f4e <kernel_gpu_opencl_wrapper+0x1c5e>
mov    -0x30(%rbp),%rdi
mov    $0x453,%esi
call   11e0 <fatal_CL@plt>
mov    -0x198(%rbp),%edi
call   1080 <clReleaseKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3040(%rip),%rcx
cmp    (%rcx),%rax
je     2f7f <kernel_gpu_opencl_wrapper+0x1c8f>
mov    -0x30(%rbp),%rdi
mov    $0x456,%esi
call   11e0 <fatal_CL@plt>
mov    -0x19c(%rbp),%edi
call   1080 <clReleaseKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x300f(%rip),%rcx
cmp    (%rcx),%rax
je     2fb0 <kernel_gpu_opencl_wrapper+0x1cc0>
mov    -0x30(%rbp),%rdi
mov    $0x459,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a0(%rbp),%edi
call   1080 <clReleaseKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2fde(%rip),%rcx
cmp    (%rcx),%rax
je     2fe1 <kernel_gpu_opencl_wrapper+0x1cf1>
mov    -0x30(%rbp),%rdi
mov    $0x45c,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a4(%rbp),%edi
call   1080 <clReleaseKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2fad(%rip),%rcx
cmp    (%rcx),%rax
je     3012 <kernel_gpu_opencl_wrapper+0x1d22>
mov    -0x30(%rbp),%rdi
mov    $0x45f,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1a8(%rbp),%edi
call   1080 <clReleaseKernel@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2f7c(%rip),%rcx
cmp    (%rcx),%rax
je     3043 <kernel_gpu_opencl_wrapper+0x1d53>
mov    -0x30(%rbp),%rdi
mov    $0x462,%esi
call   11e0 <fatal_CL@plt>
mov    -0xec(%rbp),%edi
call   10b0 <clReleaseProgram@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2f4b(%rip),%rcx
cmp    (%rcx),%rax
je     3074 <kernel_gpu_opencl_wrapper+0x1d84>
mov    -0x30(%rbp),%rdi
mov    $0x465,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1b4(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2f1a(%rip),%rcx
cmp    (%rcx),%rax
je     30a5 <kernel_gpu_opencl_wrapper+0x1db5>
mov    -0x30(%rbp),%rdi
mov    $0x46a,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1d8(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2ee9(%rip),%rcx
cmp    (%rcx),%rax
je     30d6 <kernel_gpu_opencl_wrapper+0x1de6>
mov    -0x30(%rbp),%rdi
mov    $0x46d,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1b8(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2eb8(%rip),%rcx
cmp    (%rcx),%rax
je     3107 <kernel_gpu_opencl_wrapper+0x1e17>
mov    -0x30(%rbp),%rdi
mov    $0x471,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1bc(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2e87(%rip),%rcx
cmp    (%rcx),%rax
je     3138 <kernel_gpu_opencl_wrapper+0x1e48>
mov    -0x30(%rbp),%rdi
mov    $0x474,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1c0(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2e56(%rip),%rcx
cmp    (%rcx),%rax
je     3169 <kernel_gpu_opencl_wrapper+0x1e79>
mov    -0x30(%rbp),%rdi
mov    $0x477,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1c4(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2e25(%rip),%rcx
cmp    (%rcx),%rax
je     319a <kernel_gpu_opencl_wrapper+0x1eaa>
mov    -0x30(%rbp),%rdi
mov    $0x47a,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1c8(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2df4(%rip),%rcx
cmp    (%rcx),%rax
je     31cb <kernel_gpu_opencl_wrapper+0x1edb>
mov    -0x30(%rbp),%rdi
mov    $0x47e,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1cc(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2dc3(%rip),%rcx
cmp    (%rcx),%rax
je     31fc <kernel_gpu_opencl_wrapper+0x1f0c>
mov    -0x30(%rbp),%rdi
mov    $0x481,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1d4(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2d92(%rip),%rcx
cmp    (%rcx),%rax
je     322d <kernel_gpu_opencl_wrapper+0x1f3d>
mov    -0x30(%rbp),%rdi
mov    $0x484,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1d0(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2d61(%rip),%rcx
cmp    (%rcx),%rax
je     325e <kernel_gpu_opencl_wrapper+0x1f6e>
mov    -0x30(%rbp),%rdi
mov    $0x487,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1dc(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2d30(%rip),%rcx
cmp    (%rcx),%rax
je     328f <kernel_gpu_opencl_wrapper+0x1f9f>
mov    -0x30(%rbp),%rdi
mov    $0x48b,%esi
call   11e0 <fatal_CL@plt>
mov    -0x1e0(%rbp),%edi
call   11b0 <clReleaseMemObject@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2cff(%rip),%rcx
cmp    (%rcx),%rax
je     32c0 <kernel_gpu_opencl_wrapper+0x1fd0>
mov    -0x30(%rbp),%rdi
mov    $0x48e,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
call   1090 <clFlush@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2cce(%rip),%rcx
cmp    (%rcx),%rax
je     32f1 <kernel_gpu_opencl_wrapper+0x2001>
mov    -0x30(%rbp),%rdi
mov    $0x493,%esi
call   11e0 <fatal_CL@plt>
mov    -0xd8(%rbp),%edi
call   1150 <clReleaseCommandQueue@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2c9d(%rip),%rcx
cmp    (%rcx),%rax
je     3322 <kernel_gpu_opencl_wrapper+0x2032>
mov    -0x30(%rbp),%rdi
mov    $0x496,%esi
call   11e0 <fatal_CL@plt>
mov    -0xc0(%rbp),%edi
call   1190 <clReleaseContext@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2c6c(%rip),%rcx
cmp    (%rcx),%rax
je     3353 <kernel_gpu_opencl_wrapper+0x2063>
mov    -0x30(%rbp),%rdi
mov    $0x499,%esi
call   11e0 <fatal_CL@plt>
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_gpu_opencl_wrapper>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %r9,0xa0(%rsp)
mov    %r8d,0x80(%rsp)
mov    %rdi,0xc8(%rsp)
mov    %esi,0x94(%rsp)
mov    %edx,0x90(%rsp)
mov    %rcx,0x28(%rsp)
movss  %xmm0,0x8c(%rsp)
lea    0x88(%rsp),%rdx
xor    %edi,%edi
xor    %esi,%esi
call   1120 <clGetPlatformIDs@plt>
mov    %rax,0x18(%rsp)
mov    0x3c46(%rip),%r15
cmp    (%r15),%rax
je     1374 <kernel_gpu_opencl_wrapper+0x74>
mov    %rax,%rdi
mov    $0x52,%esi
call   11f0 <fatal_CL@plt>
movslq 0x88(%rsp),%rdi
shl    $0x2,%rdi
call   1180 <malloc@plt>
mov    %rax,%rbx
mov    0x88(%rsp),%edi
mov    %rax,%rsi
xor    %edx,%edx
call   1120 <clGetPlatformIDs@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     13b0 <kernel_gpu_opencl_wrapper+0xb0>
mov    %rax,%rdi
mov    $0x5a,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%ebx
mov    0x3bdf(%rip),%rax
mov    (%rax),%esi
lea    0x110(%rsp),%rcx
mov    %ebx,%edi
mov    $0x64,%edx
xor    %r8d,%r8d
call   1150 <clGetPlatformInfo@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     13e9 <kernel_gpu_opencl_wrapper+0xe9>
mov    %rax,%rdi
mov    $0x67,%esi
call   11f0 <fatal_CL@plt>
lea    0x1c20(%rip),%rdi
lea    0x110(%rsp),%rsi
xor    %eax,%eax
call   1130 <printf@plt>
mov    0x3baa(%rip),%rax
mov    (%rax),%eax
mov    %eax,0xec(%rsp)
mov    %ebx,0xf0(%rsp)
movl   $0x0,0xf4(%rsp)
mov    0x3ba0(%rip),%rax
mov    (%rax),%esi
lea    0xec(%rsp),%rdi
lea    0x18(%rsp),%r8
xor    %edx,%edx
xor    %ecx,%ecx
call   11c0 <clCreateContextFromType@plt>
mov    %eax,%r14d
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1457 <kernel_gpu_opencl_wrapper+0x157>
mov    $0x7b,%esi
call   11f0 <fatal_CL@plt>
mov    0x3b7a(%rip),%rbp
mov    0x0(%rbp),%esi
lea    0xe0(%rsp),%r8
mov    %r14d,%edi
xor    %edx,%edx
xor    %ecx,%ecx
call   1050 <clGetContextInfo@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     148c <kernel_gpu_opencl_wrapper+0x18c>
mov    %rax,%rdi
mov    $0x89,%esi
call   11f0 <fatal_CL@plt>
mov    0xe0(%rsp),%rdi
call   1180 <malloc@plt>
mov    %rax,%rbx
mov    0x0(%rbp),%esi
mov    0xe0(%rsp),%rdx
mov    %r14d,%edi
mov    %rax,%rcx
xor    %r8d,%r8d
call   1050 <clGetContextInfo@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     14cc <kernel_gpu_opencl_wrapper+0x1cc>
mov    %rax,%rdi
mov    $0x93,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%edi
mov    %edi,0x6c(%rsp)
mov    0x3adf(%rip),%rax
mov    (%rax),%esi
lea    0x110(%rsp),%rcx
mov    $0x64,%edx
xor    %r8d,%r8d
call   10e0 <clGetDeviceInfo@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1507 <kernel_gpu_opencl_wrapper+0x207>
mov    %rax,%rdi
mov    $0xa0,%esi
call   11f0 <fatal_CL@plt>
lea    0x1b10(%rip),%rdi
lea    0x110(%rsp),%rsi
xor    %eax,%eax
call   1130 <printf@plt>
mov    0x6c(%rsp),%esi
lea    0x18(%rsp),%rcx
mov    %r14d,%edi
xor    %edx,%edx
call   1110 <clCreateCommandQueue@plt>
mov    %eax,0xac(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     154b <kernel_gpu_opencl_wrapper+0x24b>
mov    $0xae,%esi
call   11f0 <fatal_CL@plt>
lea    0x1ad8(%rip),%rdi
call   1030 <load_kernel_source@plt>
mov    %rax,0x108(%rsp)
mov    %rax,%rdi
call   10f0 <strlen@plt>
mov    %rax,0x100(%rsp)
lea    0x108(%rsp),%rdx
lea    0x100(%rsp),%rcx
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    $0x1,%esi
call   1080 <clCreateProgramWithSource@plt>
mov    %eax,%ebp
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     15a7 <kernel_gpu_opencl_wrapper+0x2a7>
mov    $0xbf,%esi
call   11f0 <fatal_CL@plt>
movl   $0x2e492d,0x180(%rsp)
lea    0x6c(%rsp),%rdx
lea    0x180(%rsp),%rcx
mov    %ebp,%edi
mov    $0x1,%esi
xor    %r8d,%r8d
xor    %r9d,%r9d
call   1040 <clBuildProgram@plt>
mov    %rax,0x18(%rsp)
lea    0x3b73(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x10000,%edx
call   1140 <memset@plt>
mov    0x6c(%rsp),%esi
mov    0x39d9(%rip),%rax
mov    (%rax),%edx
mov    %ebp,%edi
mov    $0xffff,%ecx
mov    %rbx,%r8
xor    %r9d,%r9d
call   1160 <clGetProgramBuildInfo@plt>
lea    0x1b1a(%rip),%rdi
call   1090 <puts@plt>
lea    0x1a2a(%rip),%rsi
mov    %rbx,%rdi
call   1210 <strstr@plt>
test   %rax,%rax
jne    1643 <kernel_gpu_opencl_wrapper+0x343>
lea    0x3b1e(%rip),%rdi
lea    0x1a18(%rip),%rsi
call   1210 <strstr@plt>
test   %rax,%rax
je     1658 <kernel_gpu_opencl_wrapper+0x358>
lea    0x1a0e(%rip),%rdi
lea    0x3aff(%rip),%rsi
xor    %eax,%eax
call   1130 <printf@plt>
lea    0x1aee(%rip),%rdi
call   1090 <puts@plt>
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1678 <kernel_gpu_opencl_wrapper+0x378>
mov    $0xe3,%esi
call   11f0 <fatal_CL@plt>
lea    0x19e7(%rip),%rsi
lea    0x18(%rsp),%rdx
mov    %ebp,%edi
call   11e0 <clCreateKernel@plt>
mov    %eax,%ebx
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     16a1 <kernel_gpu_opencl_wrapper+0x3a1>
mov    $0xef,%esi
call   11f0 <fatal_CL@plt>
lea    0x19cd(%rip),%rsi
lea    0x18(%rsp),%rdx
mov    %ebp,%edi
call   11e0 <clCreateKernel@plt>
mov    %eax,0x54(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     16cc <kernel_gpu_opencl_wrapper+0x3cc>
mov    $0xf7,%esi
call   11f0 <fatal_CL@plt>
lea    0x19b1(%rip),%rsi
lea    0x18(%rsp),%rdx
mov    %ebp,%edi
call   11e0 <clCreateKernel@plt>
mov    %eax,%r13d
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     16f6 <kernel_gpu_opencl_wrapper+0x3f6>
mov    $0xff,%esi
call   11f0 <fatal_CL@plt>
lea    0x1995(%rip),%rsi
lea    0x18(%rsp),%rdx
mov    %ebp,%edi
call   11e0 <clCreateKernel@plt>
mov    %eax,0x30(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1721 <kernel_gpu_opencl_wrapper+0x421>
mov    $0x107,%esi
call   11f0 <fatal_CL@plt>
lea    0x1976(%rip),%rsi
lea    0x18(%rsp),%rdx
mov    %ebp,%edi
call   11e0 <clCreateKernel@plt>
mov    %eax,0x50(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     174c <kernel_gpu_opencl_wrapper+0x44c>
mov    $0x10f,%esi
call   11f0 <fatal_CL@plt>
mov    %ebx,0x7c(%rsp)
lea    0x1954(%rip),%rsi
lea    0x18(%rsp),%rdx
mov    %ebp,0xb4(%rsp)
mov    %ebp,%edi
call   11e0 <clCreateKernel@plt>
mov    %eax,0xb0(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1785 <kernel_gpu_opencl_wrapper+0x485>
mov    $0x117,%esi
call   11f0 <fatal_CL@plt>
mov    0x278(%rsp),%ebp
mov    0x28(%rsp),%edx
shl    $0x2,%edx
mov    0x3846(%rip),%rbx
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %edx,0x78(%rsp)
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x24(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     17c7 <kernel_gpu_opencl_wrapper+0x4c7>
mov    $0x13c,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x4c(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     17f2 <kernel_gpu_opencl_wrapper+0x4f2>
mov    $0x149,%esi
call   11f0 <fatal_CL@plt>
mov    0x280(%rsp),%r12d
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x48(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1825 <kernel_gpu_opencl_wrapper+0x525>
mov    $0x152,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %r12d,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x44(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1851 <kernel_gpu_opencl_wrapper+0x551>
mov    $0x15b,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %r12d,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x40(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     187d <kernel_gpu_opencl_wrapper+0x57d>
mov    $0x164,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    0x78(%rsp),%ebp
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x68(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     18ac <kernel_gpu_opencl_wrapper+0x5ac>
mov    $0x171,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x64(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     18d7 <kernel_gpu_opencl_wrapper+0x5d7>
mov    $0x17a,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x60(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1902 <kernel_gpu_opencl_wrapper+0x602>
mov    $0x183,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x5c(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     192d <kernel_gpu_opencl_wrapper+0x62d>
mov    $0x18c,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x58(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1958 <kernel_gpu_opencl_wrapper+0x658>
mov    $0x199,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x3c(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     1983 <kernel_gpu_opencl_wrapper+0x683>
mov    $0x1a6,%esi
call   11f0 <fatal_CL@plt>
mov    (%rbx),%esi
lea    0x18(%rsp),%r8
mov    %r14d,%ebx
mov    %r14d,%edi
mov    %ebp,%edx
xor    %ecx,%ecx
call   10c0 <clCreateBuffer@plt>
mov    %eax,0x38(%rsp)
mov    0x18(%rsp),%rdi
cmp    (%r15),%rdi
je     19b1 <kernel_gpu_opencl_wrapper+0x6b1>
mov    $0x1af,%esi
call   11f0 <fatal_CL@plt>
mov    0x250(%rsp),%r14
mov    0x24(%rsp),%esi
movl   $0x0,0x10(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    0xac(%rsp),%r12d
mov    %r12d,%edi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    %ebp,%r8d
mov    0xc8(%rsp),%r9
xor    %eax,%eax
call   1220 <clEnqueueWriteBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1a0f <kernel_gpu_opencl_wrapper+0x70f>
mov    %rax,%rdi
mov    $0x1c7,%esi
call   11f0 <fatal_CL@plt>
mov    0x4c(%rsp),%esi
movl   $0x0,0x10(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x278(%rsp),%ebp
mov    %ebp,%r8d
mov    %r14,%r9
xor    %eax,%eax
call   1220 <clEnqueueWriteBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
mov    %ebx,0xb8(%rsp)
je     1a66 <kernel_gpu_opencl_wrapper+0x766>
mov    %rax,%rdi
mov    $0x1d7,%esi
call   11f0 <fatal_CL@plt>
mov    0x260(%rsp),%rbx
mov    0x48(%rsp),%esi
movl   $0x0,0x10(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    %ebp,%r8d
mov    0x258(%rsp),%r9
xor    %eax,%eax
call   1220 <clEnqueueWriteBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1abc <kernel_gpu_opencl_wrapper+0x7bc>
mov    %rax,%rdi
mov    $0x1e3,%esi
call   11f0 <fatal_CL@plt>
mov    0x268(%rsp),%rbp
mov    0x44(%rsp),%esi
movl   $0x0,0x10(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x280(%rsp),%r14d
mov    %r14d,%r8d
mov    %rbx,%r9
xor    %eax,%eax
call   1220 <clEnqueueWriteBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1b15 <kernel_gpu_opencl_wrapper+0x815>
mov    %rax,%rdi
mov    $0x1ef,%esi
call   11f0 <fatal_CL@plt>
mov    0x40(%rsp),%esi
movl   $0x0,0x10(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    %r14d,%r8d
mov    %rbp,%r9
xor    %eax,%eax
call   1220 <clEnqueueWriteBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
mov    0x7c(%rsp),%ebx
je     1b62 <kernel_gpu_opencl_wrapper+0x862>
mov    %rax,%rdi
mov    $0x1fb,%esi
call   11f0 <fatal_CL@plt>
mov    0x28(%rsp),%rax
lea    0x7f(%rax),%rcx
test   %rax,%rax
cmovns %rax,%rcx
shr    $0x7,%rcx
and    $0x7f,%eax
cmp    $0x1,%rax
sbb    $0xffffffff,%ecx
movq   $0x80,0x98(%rsp)
mov    %rcx,0xf8(%rsp)
movslq %ecx,%rsi
mov    %rsi,%rax
shl    $0x7,%rax
mov    %rax,0x70(%rsp)
lea    0x1511(%rip),%rdi
mov    $0x80,%edx
xor    %eax,%eax
call   1130 <printf@plt>
lea    0x28(%rsp),%rcx
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x8,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1be0 <kernel_gpu_opencl_wrapper+0x8e0>
mov    %rax,%rdi
mov    $0x222,%esi
call   11f0 <fatal_CL@plt>
lea    0x24(%rsp),%rcx
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1c0d <kernel_gpu_opencl_wrapper+0x90d>
mov    %rax,%rdi
mov    $0x228,%esi
call   11f0 <fatal_CL@plt>
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
lea    0x70(%rsp),%r8
lea    0x98(%rsp),%r9
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
call   1100 <clEnqueueNDRangeKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1c51 <kernel_gpu_opencl_wrapper+0x951>
mov    %rax,%rdi
mov    $0x238,%esi
call   11f0 <fatal_CL@plt>
lea    0x28(%rsp),%rcx
mov    0x54(%rsp),%ebx
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x8,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1c7f <kernel_gpu_opencl_wrapper+0x97f>
mov    %rax,%rdi
mov    $0x253,%esi
call   11f0 <fatal_CL@plt>
lea    0x24(%rsp),%rcx
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1cac <kernel_gpu_opencl_wrapper+0x9ac>
mov    %rax,%rdi
mov    $0x259,%esi
call   11f0 <fatal_CL@plt>
lea    0x3c(%rsp),%rcx
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1cd9 <kernel_gpu_opencl_wrapper+0x9d9>
mov    %rax,%rdi
mov    $0x25f,%esi
call   11f0 <fatal_CL@plt>
lea    0x38(%rsp),%rcx
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1d06 <kernel_gpu_opencl_wrapper+0xa06>
mov    %rax,%rdi
mov    $0x265,%esi
call   11f0 <fatal_CL@plt>
lea    0x28(%rsp),%rcx
mov    %r13d,%edi
xor    %esi,%esi
mov    $0x8,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
mov    0x30(%rsp),%ebx
je     1d35 <kernel_gpu_opencl_wrapper+0xa35>
mov    %rax,%rdi
mov    $0x27d,%esi
call   11f0 <fatal_CL@plt>
lea    0x3c(%rsp),%rcx
mov    %r13d,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1d63 <kernel_gpu_opencl_wrapper+0xa63>
mov    %rax,%rdi
mov    $0x283,%esi
call   11f0 <fatal_CL@plt>
lea    0x38(%rsp),%rcx
mov    %r13d,%edi
mov    $0x4,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1d91 <kernel_gpu_opencl_wrapper+0xa91>
mov    %rax,%rdi
mov    $0x289,%esi
call   11f0 <fatal_CL@plt>
lea    0x8c(%rsp),%rcx
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1dbe <kernel_gpu_opencl_wrapper+0xabe>
mov    %rax,%rdi
mov    $0x294,%esi
call   11f0 <fatal_CL@plt>
lea    0x94(%rsp),%rcx
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1dee <kernel_gpu_opencl_wrapper+0xaee>
mov    %rax,%rdi
mov    $0x29a,%esi
call   11f0 <fatal_CL@plt>
lea    0x90(%rsp),%rcx
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1e1e <kernel_gpu_opencl_wrapper+0xb1e>
mov    %rax,%rdi
mov    $0x2a0,%esi
call   11f0 <fatal_CL@plt>
lea    0x28(%rsp),%rcx
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x8,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1e4b <kernel_gpu_opencl_wrapper+0xb4b>
mov    %rax,%rdi
mov    $0x2a6,%esi
call   11f0 <fatal_CL@plt>
lea    0x4c(%rsp),%rcx
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1e78 <kernel_gpu_opencl_wrapper+0xb78>
mov    %rax,%rdi
mov    $0x2ac,%esi
call   11f0 <fatal_CL@plt>
lea    0x48(%rsp),%rcx
mov    %ebx,%edi
mov    $0x5,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1ea5 <kernel_gpu_opencl_wrapper+0xba5>
mov    %rax,%rdi
mov    $0x2b2,%esi
call   11f0 <fatal_CL@plt>
lea    0x44(%rsp),%rcx
mov    %ebx,%edi
mov    $0x6,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1ed2 <kernel_gpu_opencl_wrapper+0xbd2>
mov    %rax,%rdi
mov    $0x2b8,%esi
call   11f0 <fatal_CL@plt>
lea    0x40(%rsp),%rcx
mov    %ebx,%edi
mov    $0x7,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1eff <kernel_gpu_opencl_wrapper+0xbff>
mov    %rax,%rdi
mov    $0x2be,%esi
call   11f0 <fatal_CL@plt>
lea    0x68(%rsp),%rcx
mov    %ebx,%edi
mov    $0x8,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1f2c <kernel_gpu_opencl_wrapper+0xc2c>
mov    %rax,%rdi
mov    $0x2c4,%esi
call   11f0 <fatal_CL@plt>
lea    0x64(%rsp),%rcx
mov    %ebx,%edi
mov    $0x9,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1f59 <kernel_gpu_opencl_wrapper+0xc59>
mov    %rax,%rdi
mov    $0x2ca,%esi
call   11f0 <fatal_CL@plt>
lea    0x60(%rsp),%rcx
mov    %ebx,%edi
mov    $0xa,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1f86 <kernel_gpu_opencl_wrapper+0xc86>
mov    %rax,%rdi
mov    $0x2d0,%esi
call   11f0 <fatal_CL@plt>
lea    0x5c(%rsp),%rcx
mov    %ebx,%edi
mov    $0xb,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1fb3 <kernel_gpu_opencl_wrapper+0xcb3>
mov    %rax,%rdi
mov    $0x2d6,%esi
call   11f0 <fatal_CL@plt>
lea    0x58(%rsp),%rcx
mov    %ebx,%edi
mov    $0xd,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     1fe0 <kernel_gpu_opencl_wrapper+0xce0>
mov    %rax,%rdi
mov    $0x2dc,%esi
call   11f0 <fatal_CL@plt>
lea    0x24(%rsp),%rcx
mov    %ebx,%edi
mov    $0xe,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     200d <kernel_gpu_opencl_wrapper+0xd0d>
mov    %rax,%rdi
mov    $0x2e2,%esi
call   11f0 <fatal_CL@plt>
lea    0x8c(%rsp),%rcx
mov    0x50(%rsp),%ebx
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     203e <kernel_gpu_opencl_wrapper+0xd3e>
mov    %rax,%rdi
mov    $0x2ed,%esi
call   11f0 <fatal_CL@plt>
lea    0x94(%rsp),%rcx
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     206e <kernel_gpu_opencl_wrapper+0xd6e>
mov    %rax,%rdi
mov    $0x2f3,%esi
call   11f0 <fatal_CL@plt>
lea    0x90(%rsp),%rcx
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     209e <kernel_gpu_opencl_wrapper+0xd9e>
mov    %rax,%rdi
mov    $0x2f9,%esi
call   11f0 <fatal_CL@plt>
lea    0x28(%rsp),%rcx
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x8,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     20cb <kernel_gpu_opencl_wrapper+0xdcb>
mov    %rax,%rdi
mov    $0x2ff,%esi
call   11f0 <fatal_CL@plt>
lea    0x4c(%rsp),%rcx
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     20f8 <kernel_gpu_opencl_wrapper+0xdf8>
mov    %rax,%rdi
mov    $0x305,%esi
call   11f0 <fatal_CL@plt>
lea    0x48(%rsp),%rcx
mov    %ebx,%edi
mov    $0x5,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     2125 <kernel_gpu_opencl_wrapper+0xe25>
mov    %rax,%rdi
mov    $0x30b,%esi
call   11f0 <fatal_CL@plt>
lea    0x44(%rsp),%rcx
mov    %ebx,%edi
mov    $0x6,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     2152 <kernel_gpu_opencl_wrapper+0xe52>
mov    %rax,%rdi
mov    $0x311,%esi
call   11f0 <fatal_CL@plt>
lea    0x40(%rsp),%rcx
mov    %ebx,%edi
mov    $0x7,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     217f <kernel_gpu_opencl_wrapper+0xe7f>
mov    %rax,%rdi
mov    $0x317,%esi
call   11f0 <fatal_CL@plt>
lea    0x68(%rsp),%rcx
mov    %ebx,%edi
mov    $0x8,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     21ac <kernel_gpu_opencl_wrapper+0xeac>
mov    %rax,%rdi
mov    $0x31d,%esi
call   11f0 <fatal_CL@plt>
lea    0x64(%rsp),%rcx
mov    %ebx,%edi
mov    $0x9,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     21d9 <kernel_gpu_opencl_wrapper+0xed9>
mov    %rax,%rdi
mov    $0x323,%esi
call   11f0 <fatal_CL@plt>
lea    0x60(%rsp),%rcx
mov    %ebx,%edi
mov    $0xa,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     2206 <kernel_gpu_opencl_wrapper+0xf06>
mov    %rax,%rdi
mov    $0x329,%esi
call   11f0 <fatal_CL@plt>
lea    0x5c(%rsp),%rcx
mov    %ebx,%edi
mov    $0xb,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     2233 <kernel_gpu_opencl_wrapper+0xf33>
mov    %rax,%rdi
mov    $0x32f,%esi
call   11f0 <fatal_CL@plt>
lea    0x58(%rsp),%rcx
mov    %ebx,%edi
mov    $0xc,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r15),%rax
je     2260 <kernel_gpu_opencl_wrapper+0xf60>
mov    %rax,%rdi
mov    $0x335,%esi
call   11f0 <fatal_CL@plt>
lea    0x24(%rsp),%rcx
mov    %ebx,%edi
mov    $0xd,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
mov    %r15,%r14
cmp    (%r15),%rax
je     2290 <kernel_gpu_opencl_wrapper+0xf90>
mov    %rax,%rdi
mov    $0x33b,%esi
call   11f0 <fatal_CL@plt>
lea    0xe7b(%rip),%rdi
xor    %eax,%eax
call   1130 <printf@plt>
cmpl   $0x0,0x80(%rsp)
jle    2643 <kernel_gpu_opencl_wrapper+0x1343>
cvtsi2ssq 0xa0(%rsp),%xmm0
movss  %xmm0,0xa0(%rsp)
lea    0x98(%rsp),%r15
lea    0xd8(%rsp),%rbp
xor    %ebx,%ebx
jmp    22f0 <kernel_gpu_opencl_wrapper+0xff0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebx
cmp    0x80(%rsp),%ebx
je     2643 <kernel_gpu_opencl_wrapper+0x1343>
lea    0xe31(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1130 <printf@plt>
xor    %edi,%edi
call   1190 <fflush@plt>
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    0x54(%rsp),%esi
mov    $0x1,%edx
xor    %ecx,%ecx
lea    0x70(%rsp),%r8
mov    %r15,%r9
call   1100 <clEnqueueNDRangeKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     2348 <kernel_gpu_opencl_wrapper+0x1048>
mov    %rax,%rdi
mov    $0x35c,%esi
call   11f0 <fatal_CL@plt>
mov    0xf8(%rsp),%rcx
mov    %ecx,0x34(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x28(%rsp),%rax
mov    %rax,0xd0(%rsp)
movl   $0x1,0x84(%rsp)
test   %ecx,%ecx
je     24b8 <kernel_gpu_opencl_wrapper+0x11b8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13d,%edi
mov    $0x1,%esi
mov    $0x8,%edx
lea    0xd0(%rsp),%rcx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     23c1 <kernel_gpu_opencl_wrapper+0x10c1>
mov    %rax,%rdi
mov    $0x376,%esi
call   11f0 <fatal_CL@plt>
mov    %r13d,%edi
mov    $0x2,%esi
mov    $0x4,%edx
lea    0x84(%rsp),%rcx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     23f2 <kernel_gpu_opencl_wrapper+0x10f2>
mov    %rax,%rdi
mov    $0x37c,%esi
call   11f0 <fatal_CL@plt>
mov    %r13d,%edi
mov    $0x5,%esi
mov    $0x4,%edx
lea    0x34(%rsp),%rcx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     2420 <kernel_gpu_opencl_wrapper+0x1120>
mov    %rax,%rdi
mov    $0x383,%esi
call   11f0 <fatal_CL@plt>
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    %r13d,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    %rbp,%r8
mov    %r15,%r9
call   1100 <clEnqueueNDRangeKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     245e <kernel_gpu_opencl_wrapper+0x115e>
mov    %rax,%rdi
mov    $0x390,%esi
call   11f0 <fatal_CL@plt>
movslq 0x34(%rsp),%rax
mov    %rax,0xd0(%rsp)
cmp    $0x1,%rax
je     24b0 <kernel_gpu_opencl_wrapper+0x11b0>
shll   $0x7,0x84(%rsp)
07
mov    0x98(%rsp),%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
sbb    $0xffffffff,%eax
mov    %eax,0x34(%rsp)
imul   %eax,%ecx
movslq %ecx,%rcx
mov    %rcx,0xd8(%rsp)
test   %eax,%eax
jne    2390 <kernel_gpu_opencl_wrapper+0x1090>
jmp    24b8 <kernel_gpu_opencl_wrapper+0x11b8>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,0x34(%rsp)
mov    0x3c(%rsp),%esi
mov    0x2b25(%rip),%rax
mov    (%rax),%edx
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
xor    %ecx,%ecx
mov    $0x4,%r8d
lea    0xc4(%rsp),%r9
call   11a0 <clEnqueueReadBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     2503 <kernel_gpu_opencl_wrapper+0x1203>
mov    %rax,%rdi
mov    $0x3b3,%esi
call   11f0 <fatal_CL@plt>
mov    0x38(%rsp),%esi
mov    0x2ada(%rip),%rax
mov    (%rax),%edx
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
xor    %ecx,%ecx
mov    $0x4,%r8d
lea    0xc0(%rsp),%r9
call   11a0 <clEnqueueReadBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     254e <kernel_gpu_opencl_wrapper+0x124e>
mov    %rax,%rdi
mov    $0x3bf,%esi
call   11f0 <fatal_CL@plt>
movss  0xc4(%rsp),%xmm0
movss  0xa0(%rsp),%xmm2
divss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
movss  0xc0(%rsp),%xmm1
divss  %xmm2,%xmm1
subss  %xmm0,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xbc(%rsp)
mov    0x30(%rsp),%edi
mov    $0xc,%esi
mov    $0x4,%edx
lea    0xbc(%rsp),%rcx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     25b8 <kernel_gpu_opencl_wrapper+0x12b8>
mov    %rax,%rdi
mov    $0x3d4,%esi
call   11f0 <fatal_CL@plt>
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    0x30(%rsp),%esi
mov    $0x1,%edx
xor    %ecx,%ecx
lea    0x70(%rsp),%r8
mov    %r15,%r9
call   1100 <clEnqueueNDRangeKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     25f9 <kernel_gpu_opencl_wrapper+0x12f9>
mov    %rax,%rdi
mov    $0x3e1,%esi
call   11f0 <fatal_CL@plt>
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
mov    0x50(%rsp),%esi
mov    $0x1,%edx
xor    %ecx,%ecx
lea    0x70(%rsp),%r8
mov    %r15,%r9
call   1100 <clEnqueueNDRangeKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%r14),%rax
je     22e0 <kernel_gpu_opencl_wrapper+0xfe0>
mov    %rax,%rdi
mov    $0x3f7,%esi
call   11f0 <fatal_CL@plt>
jmp    22e0 <kernel_gpu_opencl_wrapper+0xfe0>
mov    $0xa,%edi
call   1060 <putchar@plt>
lea    0x28(%rsp),%rcx
mov    0xb0(%rsp),%ebp
mov    %ebp,%edi
xor    %esi,%esi
mov    $0x8,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
mov    %r14,%rbx
cmp    (%r14),%rax
je     2681 <kernel_gpu_opencl_wrapper+0x1381>
mov    %rax,%rdi
mov    $0x413,%esi
call   11f0 <fatal_CL@plt>
lea    0x24(%rsp),%rcx
mov    %ebp,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   1200 <clSetKernelArg@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
mov    0xb8(%rsp),%r14d
mov    0x78(%rsp),%r15d
je     26bb <kernel_gpu_opencl_wrapper+0x13bb>
mov    %rax,%rdi
mov    $0x419,%esi
call   11f0 <fatal_CL@plt>
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
lea    0x70(%rsp),%r8
lea    0x98(%rsp),%r9
mov    %r12d,%edi
mov    %ebp,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
call   1100 <clEnqueueNDRangeKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     26ff <kernel_gpu_opencl_wrapper+0x13ff>
mov    %rax,%rdi
mov    $0x429,%esi
call   11f0 <fatal_CL@plt>
mov    %r12d,%edi
call   1070 <clFinish@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     271e <kernel_gpu_opencl_wrapper+0x141e>
mov    %rax,%rdi
mov    $0x431,%esi
call   11f0 <fatal_CL@plt>
mov    0x24(%rsp),%esi
mov    0x28bf(%rip),%rax
mov    (%rax),%edx
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsp)
movl   $0x0,(%rsp)
mov    %r12d,%edi
xor    %ecx,%ecx
mov    %r15d,%r8d
mov    0xc8(%rsp),%r9
call   11a0 <clEnqueueReadBuffer@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2766 <kernel_gpu_opencl_wrapper+0x1466>
mov    %rax,%rdi
mov    $0x445,%esi
call   11f0 <fatal_CL@plt>
mov    0x7c(%rsp),%edi
call   10a0 <clReleaseKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2786 <kernel_gpu_opencl_wrapper+0x1486>
mov    %rax,%rdi
mov    $0x453,%esi
call   11f0 <fatal_CL@plt>
mov    0x54(%rsp),%edi
call   10a0 <clReleaseKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     27a6 <kernel_gpu_opencl_wrapper+0x14a6>
mov    %rax,%rdi
mov    $0x456,%esi
call   11f0 <fatal_CL@plt>
mov    %r13d,%edi
call   10a0 <clReleaseKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     27c5 <kernel_gpu_opencl_wrapper+0x14c5>
mov    %rax,%rdi
mov    $0x459,%esi
call   11f0 <fatal_CL@plt>
mov    0x30(%rsp),%edi
call   10a0 <clReleaseKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     27e5 <kernel_gpu_opencl_wrapper+0x14e5>
mov    %rax,%rdi
mov    $0x45c,%esi
call   11f0 <fatal_CL@plt>
mov    0x50(%rsp),%edi
call   10a0 <clReleaseKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2805 <kernel_gpu_opencl_wrapper+0x1505>
mov    %rax,%rdi
mov    $0x45f,%esi
call   11f0 <fatal_CL@plt>
mov    %ebp,%edi
call   10a0 <clReleaseKernel@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2823 <kernel_gpu_opencl_wrapper+0x1523>
mov    %rax,%rdi
mov    $0x462,%esi
call   11f0 <fatal_CL@plt>
mov    0xb4(%rsp),%edi
call   10d0 <clReleaseProgram@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2846 <kernel_gpu_opencl_wrapper+0x1546>
mov    %rax,%rdi
mov    $0x465,%esi
call   11f0 <fatal_CL@plt>
mov    0x24(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2866 <kernel_gpu_opencl_wrapper+0x1566>
mov    %rax,%rdi
mov    $0x46a,%esi
call   11f0 <fatal_CL@plt>
mov    0x58(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2886 <kernel_gpu_opencl_wrapper+0x1586>
mov    %rax,%rdi
mov    $0x46d,%esi
call   11f0 <fatal_CL@plt>
mov    0x4c(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     28a6 <kernel_gpu_opencl_wrapper+0x15a6>
mov    %rax,%rdi
mov    $0x471,%esi
call   11f0 <fatal_CL@plt>
mov    0x48(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     28c6 <kernel_gpu_opencl_wrapper+0x15c6>
mov    %rax,%rdi
mov    $0x474,%esi
call   11f0 <fatal_CL@plt>
mov    0x44(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     28e6 <kernel_gpu_opencl_wrapper+0x15e6>
mov    %rax,%rdi
mov    $0x477,%esi
call   11f0 <fatal_CL@plt>
mov    0x40(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2906 <kernel_gpu_opencl_wrapper+0x1606>
mov    %rax,%rdi
mov    $0x47a,%esi
call   11f0 <fatal_CL@plt>
mov    0x68(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2926 <kernel_gpu_opencl_wrapper+0x1626>
mov    %rax,%rdi
mov    $0x47e,%esi
call   11f0 <fatal_CL@plt>
mov    0x64(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2946 <kernel_gpu_opencl_wrapper+0x1646>
mov    %rax,%rdi
mov    $0x481,%esi
call   11f0 <fatal_CL@plt>
mov    0x5c(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2966 <kernel_gpu_opencl_wrapper+0x1666>
mov    %rax,%rdi
mov    $0x484,%esi
call   11f0 <fatal_CL@plt>
mov    0x60(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2986 <kernel_gpu_opencl_wrapper+0x1686>
mov    %rax,%rdi
mov    $0x487,%esi
call   11f0 <fatal_CL@plt>
mov    0x3c(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     29a6 <kernel_gpu_opencl_wrapper+0x16a6>
mov    %rax,%rdi
mov    $0x48b,%esi
call   11f0 <fatal_CL@plt>
mov    0x38(%rsp),%edi
call   11d0 <clReleaseMemObject@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     29c6 <kernel_gpu_opencl_wrapper+0x16c6>
mov    %rax,%rdi
mov    $0x48e,%esi
call   11f0 <fatal_CL@plt>
mov    %r12d,%edi
call   10b0 <clFlush@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     29e5 <kernel_gpu_opencl_wrapper+0x16e5>
mov    %rax,%rdi
mov    $0x493,%esi
call   11f0 <fatal_CL@plt>
mov    %r12d,%edi
call   1170 <clReleaseCommandQueue@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2a04 <kernel_gpu_opencl_wrapper+0x1704>
mov    %rax,%rdi
mov    $0x496,%esi
call   11f0 <fatal_CL@plt>
mov    %r14d,%edi
call   11b0 <clReleaseContext@plt>
mov    %rax,0x18(%rsp)
cmp    (%rbx),%rax
je     2a23 <kernel_gpu_opencl_wrapper+0x1723>
mov    %rax,%rdi
mov    $0x499,%esi
call   11f0 <fatal_CL@plt>
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@CL_SUCCESS = global i64 0
@CL_PLATFORM_VENDOR = global i32 0
@.str = [14 x i8] c"Platform: %s\0A\00"
@CL_CONTEXT_PLATFORM = global i32 0
@CL_DEVICE_TYPE_ALL = global i32 0
@CL_CONTEXT_DEVICES = global i32 0
@CL_DEVICE_NAME = global i32 0
@.str.1 = [12 x i8] c"Device: %s\0A\00"
@.str.2 = [30 x i8] c"./kernel/kernel_gpu_opencl.cl\00"
@.str.3 = [4 x i8] c"-I.\00"
@kernel_gpu_opencl_wrapper.log = internal global [65536 x i8] zeroinitializer
@CL_PROGRAM_BUILD_LOG = global i32 0
@.str.4 = [34 x i8] c"-----OpenCL Compiler Output-----\0A\00"
@.str.5 = [9 x i8] c"warning:\00"
@.str.6 = [7 x i8] c"error:\00"
@.str.7 = [14 x i8] c"<<<<\0A%s\0A>>>>\0A\00"
@.str.8 = [34 x i8] c"--------------------------------\0A\00"
@.str.9 = [15 x i8] c"extract_kernel\00"
@.str.10 = [15 x i8] c"prepare_kernel\00"
@.str.11 = [14 x i8] c"reduce_kernel\00"
@.str.12 = [12 x i8] c"srad_kernel\00"
@.str.13 = [13 x i8] c"srad2_kernel\00"
@.str.14 = [16 x i8] c"compress_kernel\00"
@CL_MEM_READ_WRITE = global i32 0
@.str.15 = [87 x i8] c"max # of workgroups = %d, # of threads/workgroup = %d (ensure that device can handle)\0A\00"
@.str.16 = [22 x i8] c"Iterations Progress: \00"
@.str.17 = [4 x i8] c"%d \00"
@CL_TRUE = global i32 0
@.str.18 = [2 x i8] c"\0A\00"
define void @kernel_gpu_opencl_wrapper(float* %0, i32 %1, i32 %2, i64 %3, i32 %4, float %5, i64 %6, i32* %7, i32* %8, i32* %9, i32* %10, i32 %11, i32 %12, i32 %13) {
%15 = alloca float*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i64
%19 = alloca i32
%20 = alloca float
%21 = alloca i64
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i64
%30 = alloca i32
%31 = alloca i32*
%32 = alloca i32
%33 = alloca [100 x i8]
%34 = alloca [3 x i32]
%35 = alloca i32
%36 = alloca i64
%37 = alloca i32*
%38 = alloca i32
%39 = alloca i32
%40 = alloca i8*
%41 = alloca i64
%42 = alloca i32
%43 = alloca [150 x i8]
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca [1 x i64]
%65 = alloca i32
%66 = alloca [1 x i64]
%67 = alloca i32
%68 = alloca i32
%69 = alloca [1 x i64]
%70 = alloca i64
%71 = alloca i32
%72 = alloca i32
%73 = alloca float
%74 = alloca float
%75 = alloca float
%76 = alloca float
%77 = alloca float
%78 = alloca float
store float* %0, float** %15
store i32 %1, i32* %16
store i32 %2, i32* %17
store i64 %3, i64* %18
store i32 %4, i32* %19
store float %5, float* %20
store i64 %6, i64* %21
store i32* %7, i32** %22
store i32* %8, i32** %23
store i32* %9, i32** %24
store i32* %10, i32** %25
store i32 %11, i32* %26
store i32 %12, i32* %27
store i32 %13, i32* %28
%79 = call i64 @clGetPlatformIDs(i32 0, i32* null, i32* %30)
store i64 %79, i64* %29
%80 = load i64, i64* %29
%81 = load i64, i64* @CL_SUCCESS
%82 = icmp ne i64 %80, %81
br i1 %82, label %83, label %86
83: ; preds = %14
%84 = load i64, i64* %29
%85 = call i32 @fatal_CL(i64 %84, i32 82)
br label %86
86: ; preds = %83, %14
%87 = load i32, i32* %30
%88 = sext i32 %87 to i64
%89 = mul i64 4, %88
%90 = call i64 @malloc(i64 %89)
%91 = inttoptr i64 %90 to i32*
store i32* %91, i32** %31
%92 = load i32, i32* %30
%93 = load i32*, i32** %31
%94 = call i64 @clGetPlatformIDs(i32 %92, i32* %93, i32* null)
store i64 %94, i64* %29
%95 = load i64, i64* %29
%96 = load i64, i64* @CL_SUCCESS
%97 = icmp ne i64 %95, %96
br i1 %97, label %98, label %101
98: ; preds = %86
%99 = load i64, i64* %29
%100 = call i32 @fatal_CL(i64 %99, i32 90)
br label %101
101: ; preds = %98, %86
%102 = load i32*, i32** %31
%103 = getelementptr inbounds i32, i32* %102, i64 0
%104 = load i32, i32* %103
store i32 %104, i32* %32
%105 = load i32, i32* %32
%106 = load i32, i32* @CL_PLATFORM_VENDOR
%107 = getelementptr inbounds [100 x i8], [100 x i8]* %33, i64 0, i64 0
%108 = call i64 @clGetPlatformInfo(i32 %105, i32 %106, i32 100, i8* %107, i32* null)
store i64 %108, i64* %29
%109 = load i64, i64* %29
%110 = load i64, i64* @CL_SUCCESS
%111 = icmp ne i64 %109, %110
br i1 %111, label %112, label %115
112: ; preds = %101
%113 = load i64, i64* %29
%114 = call i32 @fatal_CL(i64 %113, i32 103)
br label %115
115: ; preds = %112, %101
%116 = getelementptr inbounds [100 x i8], [100 x i8]* %33, i64 0, i64 0
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i8* %116)
%118 = getelementptr inbounds [3 x i32], [3 x i32]* %34, i64 0, i64 0
%119 = load i32, i32* @CL_CONTEXT_PLATFORM
store i32 %119, i32* %118
%120 = getelementptr inbounds i32, i32* %118, i64 1
%121 = load i32, i32* %32
store i32 %121, i32* %120
%122 = getelementptr inbounds i32, i32* %120, i64 1
store i32 0, i32* %122
%123 = getelementptr inbounds [3 x i32], [3 x i32]* %34, i64 0, i64 0
%124 = load i32, i32* @CL_DEVICE_TYPE_ALL
%125 = call i32 @clCreateContextFromType(i32* %123, i32 %124, i32* null, i32* null, i64* %29)
store i32 %125, i32* %35
%126 = load i64, i64* %29
%127 = load i64, i64* @CL_SUCCESS
%128 = icmp ne i64 %126, %127
br i1 %128, label %129, label %132
129: ; preds = %115
%130 = load i64, i64* %29
%131 = call i32 @fatal_CL(i64 %130, i32 123)
br label %132
132: ; preds = %129, %115
%133 = load i32, i32* %35
%134 = load i32, i32* @CL_CONTEXT_DEVICES
%135 = call i64 @clGetContextInfo(i32 %133, i32 %134, i64 0, i32* null, i64* %36)
store i64 %135, i64* %29
%136 = load i64, i64* %29
%137 = load i64, i64* @CL_SUCCESS
%138 = icmp ne i64 %136, %137
br i1 %138, label %139, label %142
139: ; preds = %132
%140 = load i64, i64* %29
%141 = call i32 @fatal_CL(i64 %140, i32 137)
br label %142
142: ; preds = %139, %132
%143 = load i64, i64* %36
%144 = call i64 @malloc(i64 %143)
%145 = inttoptr i64 %144 to i32*
store i32* %145, i32** %37
%146 = load i32, i32* %35
%147 = load i32, i32* @CL_CONTEXT_DEVICES
%148 = load i64, i64* %36
%149 = load i32*, i32** %37
%150 = call i64 @clGetContextInfo(i32 %146, i32 %147, i64 %148, i32* %149, i64* null)
store i64 %150, i64* %29
%151 = load i64, i64* %29
%152 = load i64, i64* @CL_SUCCESS
%153 = icmp ne i64 %151, %152
br i1 %153, label %154, label %157
154: ; preds = %142
%155 = load i64, i64* %29
%156 = call i32 @fatal_CL(i64 %155, i32 147)
br label %157
157: ; preds = %154, %142
%158 = load i32*, i32** %37
%159 = getelementptr inbounds i32, i32* %158, i64 0
%160 = load i32, i32* %159
store i32 %160, i32* %38
%161 = load i32, i32* %38
%162 = load i32, i32* @CL_DEVICE_NAME
%163 = getelementptr inbounds [100 x i8], [100 x i8]* %33, i64 0, i64 0
%164 = call i64 @clGetDeviceInfo(i32 %161, i32 %162, i32 100, i8* %163, i32* null)
store i64 %164, i64* %29
%165 = load i64, i64* %29
%166 = load i64, i64* @CL_SUCCESS
%167 = icmp ne i64 %165, %166
br i1 %167, label %168, label %171
168: ; preds = %157
%169 = load i64, i64* %29
%170 = call i32 @fatal_CL(i64 %169, i32 160)
br label %171
171: ; preds = %168, %157
%172 = getelementptr inbounds [100 x i8], [100 x i8]* %33, i64 0, i64 0
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i8* %172)
%174 = load i32, i32* %35
%175 = load i32, i32* %38
%176 = call i32 @clCreateCommandQueue(i32 %174, i32 %175, i32 0, i64* %29)
store i32 %176, i32* %39
%177 = load i64, i64* %29
%178 = load i64, i64* @CL_SUCCESS
%179 = icmp ne i64 %177, %178
br i1 %179, label %180, label %183
180: ; preds = %171
%181 = load i64, i64* %29
%182 = call i32 @fatal_CL(i64 %181, i32 174)
br label %183
183: ; preds = %180, %171
%184 = call i8* @load_kernel_source(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0))
store i8* %184, i8** %40
%185 = load i8*, i8** %40
%186 = call i64 @strlen(i8* %185)
store i64 %186, i64* %41
%187 = load i32, i32* %35
%188 = call i32 @clCreateProgramWithSource(i32 %187, i32 1, i8** %40, i64* %41, i64* %29)
store i32 %188, i32* %42
%189 = load i64, i64* %29
%190 = load i64, i64* @CL_SUCCESS
%191 = icmp ne i64 %189, %190
br i1 %191, label %192, label %195
192: ; preds = %183
%193 = load i64, i64* %29
%194 = call i32 @fatal_CL(i64 %193, i32 191)
br label %195
195: ; preds = %192, %183
%196 = getelementptr inbounds [150 x i8], [150 x i8]* %43, i64 0, i64 0
%197 = call i32 @sprintf(i8* %196, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%198 = load i32, i32* %42
%199 = getelementptr inbounds [150 x i8], [150 x i8]* %43, i64 0, i64 0
%200 = call i64 @clBuildProgram(i32 %198, i32 1, i32* %38, i8* %199, i32* null, i32* null)
store i64 %200, i64* %29
%201 = call i32 @memset(i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i32 0, i32 65536)
%202 = load i32, i32* %42
%203 = load i32, i32* %38
%204 = load i32, i32* @CL_PROGRAM_BUILD_LOG
%205 = call i32 @clGetProgramBuildInfo(i32 %202, i32 %203, i32 %204, i32 65535, i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i32* null)
%206 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0))
%207 = call i64 @strstr(i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%208 = icmp ne i64 %207, 0
br i1 %208, label %212, label %209
209: ; preds = %195
%210 = call i64 @strstr(i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0))
%211 = icmp ne i64 %210, 0
br i1 %211, label %212, label %214
212: ; preds = %209, %195
%213 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0))
br label %214
214: ; preds = %212, %209
%215 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0))
%216 = load i64, i64* %29
%217 = load i64, i64* @CL_SUCCESS
%218 = icmp ne i64 %216, %217
br i1 %218, label %219, label %222
219: ; preds = %214
%220 = load i64, i64* %29
%221 = call i32 @fatal_CL(i64 %220, i32 227)
br label %222
222: ; preds = %219, %214
%223 = load i32, i32* %42
%224 = call i32 @clCreateKernel(i32 %223, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0), i64* %29)
store i32 %224, i32* %44
%225 = load i64, i64* %29
%226 = load i64, i64* @CL_SUCCESS
%227 = icmp ne i64 %225, %226
br i1 %227, label %228, label %231
228: ; preds = %222
%229 = load i64, i64* %29
%230 = call i32 @fatal_CL(i64 %229, i32 239)
br label %231
231: ; preds = %228, %222
%232 = load i32, i32* %42
%233 = call i32 @clCreateKernel(i32 %232, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), i64* %29)
store i32 %233, i32* %45
%234 = load i64, i64* %29
%235 = load i64, i64* @CL_SUCCESS
%236 = icmp ne i64 %234, %235
br i1 %236, label %237, label %240
237: ; preds = %231
%238 = load i64, i64* %29
%239 = call i32 @fatal_CL(i64 %238, i32 247)
br label %240
240: ; preds = %237, %231
%241 = load i32, i32* %42
%242 = call i32 @clCreateKernel(i32 %241, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.11, i64 0, i64 0), i64* %29)
store i32 %242, i32* %46
%243 = load i64, i64* %29
%244 = load i64, i64* @CL_SUCCESS
%245 = icmp ne i64 %243, %244
br i1 %245, label %246, label %249
246: ; preds = %240
%247 = load i64, i64* %29
%248 = call i32 @fatal_CL(i64 %247, i32 255)
br label %249
249: ; preds = %246, %240
%250 = load i32, i32* %42
%251 = call i32 @clCreateKernel(i32 %250, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0), i64* %29)
store i32 %251, i32* %47
%252 = load i64, i64* %29
%253 = load i64, i64* @CL_SUCCESS
%254 = icmp ne i64 %252, %253
br i1 %254, label %255, label %258
255: ; preds = %249
%256 = load i64, i64* %29
%257 = call i32 @fatal_CL(i64 %256, i32 263)
br label %258
258: ; preds = %255, %249
%259 = load i32, i32* %42
%260 = call i32 @clCreateKernel(i32 %259, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.13, i64 0, i64 0), i64* %29)
store i32 %260, i32* %48
%261 = load i64, i64* %29
%262 = load i64, i64* @CL_SUCCESS
%263 = icmp ne i64 %261, %262
br i1 %263, label %264, label %267
264: ; preds = %258
%265 = load i64, i64* %29
%266 = call i32 @fatal_CL(i64 %265, i32 271)
br label %267
267: ; preds = %264, %258
%268 = load i32, i32* %42
%269 = call i32 @clCreateKernel(i32 %268, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.14, i64 0, i64 0), i64* %29)
store i32 %269, i32* %49
%270 = load i64, i64* %29
%271 = load i64, i64* @CL_SUCCESS
%272 = icmp ne i64 %270, %271
br i1 %272, label %273, label %276
273: ; preds = %267
%274 = load i64, i64* %29
%275 = call i32 @fatal_CL(i64 %274, i32 279)
br label %276
276: ; preds = %273, %267
%277 = load i64, i64* %18
%278 = mul i64 4, %277
%279 = trunc i64 %278 to i32
store i32 %279, i32* %51
%280 = load i32, i32* %35
%281 = load i32, i32* @CL_MEM_READ_WRITE
%282 = load i32, i32* %51
%283 = call i32 @clCreateBuffer(i32 %280, i32 %281, i32 %282, i32* null, i64* %29)
store i32 %283, i32* %52
%284 = load i64, i64* %29
%285 = load i64, i64* @CL_SUCCESS
%286 = icmp ne i64 %284, %285
br i1 %286, label %287, label %290
287: ; preds = %276
%288 = load i64, i64* %29
%289 = call i32 @fatal_CL(i64 %288, i32 316)
br label %290
290: ; preds = %287, %276
%291 = load i32, i32* %35
%292 = load i32, i32* @CL_MEM_READ_WRITE
%293 = load i32, i32* %27
%294 = call i32 @clCreateBuffer(i32 %291, i32 %292, i32 %293, i32* null, i64* %29)
store i32 %294, i32* %53
%295 = load i64, i64* %29
%296 = load i64, i64* @CL_SUCCESS
%297 = icmp ne i64 %295, %296
br i1 %297, label %298, label %301
298: ; preds = %290
%299 = load i64, i64* %29
%300 = call i32 @fatal_CL(i64 %299, i32 329)
br label %301
301: ; preds = %298, %290
%302 = load i32, i32* %35
%303 = load i32, i32* @CL_MEM_READ_WRITE
%304 = load i32, i32* %27
%305 = call i32 @clCreateBuffer(i32 %302, i32 %303, i32 %304, i32* null, i64* %29)
store i32 %305, i32* %54
%306 = load i64, i64* %29
%307 = load i64, i64* @CL_SUCCESS
%308 = icmp ne i64 %306, %307
br i1 %308, label %309, label %312
309: ; preds = %301
%310 = load i64, i64* %29
%311 = call i32 @fatal_CL(i64 %310, i32 338)
br label %312
312: ; preds = %309, %301
%313 = load i32, i32* %35
%314 = load i32, i32* @CL_MEM_READ_WRITE
%315 = load i32, i32* %28
%316 = call i32 @clCreateBuffer(i32 %313, i32 %314, i32 %315, i32* null, i64* %29)
store i32 %316, i32* %55
%317 = load i64, i64* %29
%318 = load i64, i64* @CL_SUCCESS
%319 = icmp ne i64 %317, %318
br i1 %319, label %320, label %323
320: ; preds = %312
%321 = load i64, i64* %29
%322 = call i32 @fatal_CL(i64 %321, i32 347)
br label %323
323: ; preds = %320, %312
%324 = load i32, i32* %35
%325 = load i32, i32* @CL_MEM_READ_WRITE
%326 = load i32, i32* %28
%327 = call i32 @clCreateBuffer(i32 %324, i32 %325, i32 %326, i32* null, i64* %29)
store i32 %327, i32* %56
%328 = load i64, i64* %29
%329 = load i64, i64* @CL_SUCCESS
%330 = icmp ne i64 %328, %329
br i1 %330, label %331, label %334
331: ; preds = %323
%332 = load i64, i64* %29
%333 = call i32 @fatal_CL(i64 %332, i32 356)
br label %334
334: ; preds = %331, %323
%335 = load i32, i32* %35
%336 = load i32, i32* @CL_MEM_READ_WRITE
%337 = load i32, i32* %51
%338 = call i32 @clCreateBuffer(i32 %335, i32 %336, i32 %337, i32* null, i64* %29)
store i32 %338, i32* %57
%339 = load i64, i64* %29
%340 = load i64, i64* @CL_SUCCESS
%341 = icmp ne i64 %339, %340
br i1 %341, label %342, label %345
342: ; preds = %334
%343 = load i64, i64* %29
%344 = call i32 @fatal_CL(i64 %343, i32 369)
br label %345
345: ; preds = %342, %334
%346 = load i32, i32* %35
%347 = load i32, i32* @CL_MEM_READ_WRITE
%348 = load i32, i32* %51
%349 = call i32 @clCreateBuffer(i32 %346, i32 %347, i32 %348, i32* null, i64* %29)
store i32 %349, i32* %58
%350 = load i64, i64* %29
%351 = load i64, i64* @CL_SUCCESS
%352 = icmp ne i64 %350, %351
br i1 %352, label %353, label %356
353: ; preds = %345
%354 = load i64, i64* %29
%355 = call i32 @fatal_CL(i64 %354, i32 378)
br label %356
356: ; preds = %353, %345
%357 = load i32, i32* %35
%358 = load i32, i32* @CL_MEM_READ_WRITE
%359 = load i32, i32* %51
%360 = call i32 @clCreateBuffer(i32 %357, i32 %358, i32 %359, i32* null, i64* %29)
store i32 %360, i32* %59
%361 = load i64, i64* %29
%362 = load i64, i64* @CL_SUCCESS
%363 = icmp ne i64 %361, %362
br i1 %363, label %364, label %367
364: ; preds = %356
%365 = load i64, i64* %29
%366 = call i32 @fatal_CL(i64 %365, i32 387)
br label %367
367: ; preds = %364, %356
%368 = load i32, i32* %35
%369 = load i32, i32* @CL_MEM_READ_WRITE
%370 = load i32, i32* %51
%371 = call i32 @clCreateBuffer(i32 %368, i32 %369, i32 %370, i32* null, i64* %29)
store i32 %371, i32* %60
%372 = load i64, i64* %29
%373 = load i64, i64* @CL_SUCCESS
%374 = icmp ne i64 %372, %373
br i1 %374, label %375, label %378
375: ; preds = %367
%376 = load i64, i64* %29
%377 = call i32 @fatal_CL(i64 %376, i32 396)
br label %378
378: ; preds = %375, %367
%379 = load i32, i32* %35
%380 = load i32, i32* @CL_MEM_READ_WRITE
%381 = load i32, i32* %51
%382 = call i32 @clCreateBuffer(i32 %379, i32 %380, i32 %381, i32* null, i64* %29)
store i32 %382, i32* %61
%383 = load i64, i64* %29
%384 = load i64, i64* @CL_SUCCESS
%385 = icmp ne i64 %383, %384
br i1 %385, label %386, label %389
386: ; preds = %378
%387 = load i64, i64* %29
%388 = call i32 @fatal_CL(i64 %387, i32 409)
br label %389
389: ; preds = %386, %378
%390 = load i32, i32* %35
%391 = load i32, i32* @CL_MEM_READ_WRITE
%392 = load i32, i32* %51
%393 = call i32 @clCreateBuffer(i32 %390, i32 %391, i32 %392, i32* null, i64* %29)
store i32 %393, i32* %62
%394 = load i64, i64* %29
%395 = load i64, i64* @CL_SUCCESS
%396 = icmp ne i64 %394, %395
br i1 %396, label %397, label %400
397: ; preds = %389
%398 = load i64, i64* %29
%399 = call i32 @fatal_CL(i64 %398, i32 422)
br label %400
400: ; preds = %397, %389
%401 = load i32, i32* %35
%402 = load i32, i32* @CL_MEM_READ_WRITE
%403 = load i32, i32* %51
%404 = call i32 @clCreateBuffer(i32 %401, i32 %402, i32 %403, i32* null, i64* %29)
store i32 %404, i32* %63
%405 = load i64, i64* %29
%406 = load i64, i64* @CL_SUCCESS
%407 = icmp ne i64 %405, %406
br i1 %407, label %408, label %411
408: ; preds = %400
%409 = load i64, i64* %29
%410 = call i32 @fatal_CL(i64 %409, i32 431)
br label %411
411: ; preds = %408, %400
%412 = load i32, i32* %39
%413 = load i32, i32* %52
%414 = load i32, i32* %51
%415 = load float*, float** %15
%416 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %412, i32 %413, i32 1, i32 0, i32 %414, float* %415, i32 0, i32 0, i32 0)
store i64 %416, i64* %29
%417 = load i64, i64* %29
%418 = load i64, i64* @CL_SUCCESS
%419 = icmp ne i64 %417, %418
br i1 %419, label %420, label %423
420: ; preds = %411
%421 = load i64, i64* %29
%422 = call i32 @fatal_CL(i64 %421, i32 455)
br label %423
423: ; preds = %420, %411
%424 = load i32, i32* %39
%425 = load i32, i32* %53
%426 = load i32, i32* %27
%427 = load i32*, i32** %22
%428 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %424, i32 %425, i32 1, i32 0, i32 %426, i32* %427, i32 0, i32 0, i32 0)
store i64 %428, i64* %29
%429 = load i64, i64* %29
%430 = load i64, i64* @CL_SUCCESS
%431 = icmp ne i64 %429, %430
br i1 %431, label %432, label %435
432: ; preds = %423
%433 = load i64, i64* %29
%434 = call i32 @fatal_CL(i64 %433, i32 471)
br label %435
435: ; preds = %432, %423
%436 = load i32, i32* %39
%437 = load i32, i32* %54
%438 = load i32, i32* %27
%439 = load i32*, i32** %23
%440 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %436, i32 %437, i32 1, i32 0, i32 %438, i32* %439, i32 0, i32 0, i32 0)
store i64 %440, i64* %29
%441 = load i64, i64* %29
%442 = load i64, i64* @CL_SUCCESS
%443 = icmp ne i64 %441, %442
br i1 %443, label %444, label %447
444: ; preds = %435
%445 = load i64, i64* %29
%446 = call i32 @fatal_CL(i64 %445, i32 483)
br label %447
447: ; preds = %444, %435
%448 = load i32, i32* %39
%449 = load i32, i32* %55
%450 = load i32, i32* %28
%451 = load i32*, i32** %24
%452 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %448, i32 %449, i32 1, i32 0, i32 %450, i32* %451, i32 0, i32 0, i32 0)
store i64 %452, i64* %29
%453 = load i64, i64* %29
%454 = load i64, i64* @CL_SUCCESS
%455 = icmp ne i64 %453, %454
br i1 %455, label %456, label %459
456: ; preds = %447
%457 = load i64, i64* %29
%458 = call i32 @fatal_CL(i64 %457, i32 495)
br label %459
459: ; preds = %456, %447
%460 = load i32, i32* %39
%461 = load i32, i32* %56
%462 = load i32, i32* %28
%463 = load i32*, i32** %25
%464 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %460, i32 %461, i32 1, i32 0, i32 %462, i32* %463, i32 0, i32 0, i32 0)
store i64 %464, i64* %29
%465 = load i64, i64* %29
%466 = load i64, i64* @CL_SUCCESS
%467 = icmp ne i64 %465, %466
br i1 %467, label %468, label %471
468: ; preds = %459
%469 = load i64, i64* %29
%470 = call i32 @fatal_CL(i64 %469, i32 507)
br label %471
471: ; preds = %468, %459
%472 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
store i64 128, i64* %472
%473 = load i64, i64* %18
%474 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%475 = load i64, i64* %474
%476 = trunc i64 %475 to i32
%477 = sext i32 %476 to i64
%478 = sdiv i64 %473, %477
%479 = trunc i64 %478 to i32
store i32 %479, i32* %50
%480 = load i64, i64* %18
%481 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%482 = load i64, i64* %481
%483 = trunc i64 %482 to i32
%484 = sext i32 %483 to i64
%485 = srem i64 %480, %484
%486 = icmp ne i64 %485, 0
br i1 %486, label %487, label %490
487: ; preds = %471
%488 = load i32, i32* %50
%489 = add nsw i32 %488, 1
store i32 %489, i32* %50
br label %490
490: ; preds = %487, %471
%491 = load i32, i32* %50
store i32 %491, i32* %65
%492 = load i32, i32* %65
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%495 = load i64, i64* %494
%496 = mul i64 %493, %495
%497 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
store i64 %496, i64* %497
%498 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%499 = load i64, i64* %498
%500 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%501 = load i64, i64* %500
%502 = udiv i64 %499, %501
%503 = trunc i64 %502 to i32
%504 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%505 = load i64, i64* %504
%506 = trunc i64 %505 to i32
%507 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.15, i64 0, i64 0), i32 %503, i32 %506)
%508 = load i32, i32* %44
%509 = bitcast i64* %18 to i8*
%510 = call i64 @clSetKernelArg(i32 %508, i32 0, i32 8, i8* %509)
store i64 %510, i64* %29
%511 = load i64, i64* %29
%512 = load i64, i64* @CL_SUCCESS
%513 = icmp ne i64 %511, %512
br i1 %513, label %514, label %517
514: ; preds = %490
%515 = load i64, i64* %29
%516 = call i32 @fatal_CL(i64 %515, i32 546)
br label %517
517: ; preds = %514, %490
%518 = load i32, i32* %44
%519 = bitcast i32* %52 to i8*
%520 = call i64 @clSetKernelArg(i32 %518, i32 1, i32 4, i8* %519)
store i64 %520, i64* %29
%521 = load i64, i64* %29
%522 = load i64, i64* @CL_SUCCESS
%523 = icmp ne i64 %521, %522
br i1 %523, label %524, label %527
524: ; preds = %517
%525 = load i64, i64* %29
%526 = call i32 @fatal_CL(i64 %525, i32 552)
br label %527
527: ; preds = %524, %517
%528 = load i32, i32* %39
%529 = load i32, i32* %44
%530 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%531 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%532 = call i64 @clEnqueueNDRangeKernel(i32 %528, i32 %529, i32 1, i32* null, i64* %530, i64* %531, i32 0, i32* null, i32* null)
store i64 %532, i64* %29
%533 = load i64, i64* %29
%534 = load i64, i64* @CL_SUCCESS
%535 = icmp ne i64 %533, %534
br i1 %535, label %536, label %539
536: ; preds = %527
%537 = load i64, i64* %29
%538 = call i32 @fatal_CL(i64 %537, i32 568)
br label %539
539: ; preds = %536, %527
%540 = load i32, i32* %45
%541 = bitcast i64* %18 to i8*
%542 = call i64 @clSetKernelArg(i32 %540, i32 0, i32 8, i8* %541)
store i64 %542, i64* %29
%543 = load i64, i64* %29
%544 = load i64, i64* @CL_SUCCESS
%545 = icmp ne i64 %543, %544
br i1 %545, label %546, label %549
546: ; preds = %539
%547 = load i64, i64* %29
%548 = call i32 @fatal_CL(i64 %547, i32 595)
br label %549
549: ; preds = %546, %539
%550 = load i32, i32* %45
%551 = bitcast i32* %52 to i8*
%552 = call i64 @clSetKernelArg(i32 %550, i32 1, i32 4, i8* %551)
store i64 %552, i64* %29
%553 = load i64, i64* %29
%554 = load i64, i64* @CL_SUCCESS
%555 = icmp ne i64 %553, %554
br i1 %555, label %556, label %559
556: ; preds = %549
%557 = load i64, i64* %29
%558 = call i32 @fatal_CL(i64 %557, i32 601)
br label %559
559: ; preds = %556, %549
%560 = load i32, i32* %45
%561 = bitcast i32* %62 to i8*
%562 = call i64 @clSetKernelArg(i32 %560, i32 2, i32 4, i8* %561)
store i64 %562, i64* %29
%563 = load i64, i64* %29
%564 = load i64, i64* @CL_SUCCESS
%565 = icmp ne i64 %563, %564
br i1 %565, label %566, label %569
566: ; preds = %559
%567 = load i64, i64* %29
%568 = call i32 @fatal_CL(i64 %567, i32 607)
br label %569
569: ; preds = %566, %559
%570 = load i32, i32* %45
%571 = bitcast i32* %63 to i8*
%572 = call i64 @clSetKernelArg(i32 %570, i32 3, i32 4, i8* %571)
store i64 %572, i64* %29
%573 = load i64, i64* %29
%574 = load i64, i64* @CL_SUCCESS
%575 = icmp ne i64 %573, %574
br i1 %575, label %576, label %579
576: ; preds = %569
%577 = load i64, i64* %29
%578 = call i32 @fatal_CL(i64 %577, i32 613)
br label %579
579: ; preds = %576, %569
store i32 4, i32* %72
%580 = load i32, i32* %46
%581 = bitcast i64* %18 to i8*
%582 = call i64 @clSetKernelArg(i32 %580, i32 0, i32 8, i8* %581)
store i64 %582, i64* %29
%583 = load i64, i64* %29
%584 = load i64, i64* @CL_SUCCESS
%585 = icmp ne i64 %583, %584
br i1 %585, label %586, label %589
586: ; preds = %579
%587 = load i64, i64* %29
%588 = call i32 @fatal_CL(i64 %587, i32 637)
br label %589
589: ; preds = %586, %579
%590 = load i32, i32* %46
%591 = bitcast i32* %62 to i8*
%592 = call i64 @clSetKernelArg(i32 %590, i32 3, i32 4, i8* %591)
store i64 %592, i64* %29
%593 = load i64, i64* %29
%594 = load i64, i64* @CL_SUCCESS
%595 = icmp ne i64 %593, %594
br i1 %595, label %596, label %599
596: ; preds = %589
%597 = load i64, i64* %29
%598 = call i32 @fatal_CL(i64 %597, i32 643)
br label %599
599: ; preds = %596, %589
%600 = load i32, i32* %46
%601 = bitcast i32* %63 to i8*
%602 = call i64 @clSetKernelArg(i32 %600, i32 4, i32 4, i8* %601)
store i64 %602, i64* %29
%603 = load i64, i64* %29
%604 = load i64, i64* @CL_SUCCESS
%605 = icmp ne i64 %603, %604
br i1 %605, label %606, label %609
606: ; preds = %599
%607 = load i64, i64* %29
%608 = call i32 @fatal_CL(i64 %607, i32 649)
br label %609
609: ; preds = %606, %599
%610 = load i32, i32* %47
%611 = bitcast float* %20 to i8*
%612 = call i64 @clSetKernelArg(i32 %610, i32 0, i32 4, i8* %611)
store i64 %612, i64* %29
%613 = load i64, i64* %29
%614 = load i64, i64* @CL_SUCCESS
%615 = icmp ne i64 %613, %614
br i1 %615, label %616, label %619
616: ; preds = %609
%617 = load i64, i64* %29
%618 = call i32 @fatal_CL(i64 %617, i32 660)
br label %619
619: ; preds = %616, %609
%620 = load i32, i32* %47
%621 = bitcast i32* %16 to i8*
%622 = call i64 @clSetKernelArg(i32 %620, i32 1, i32 4, i8* %621)
store i64 %622, i64* %29
%623 = load i64, i64* %29
%624 = load i64, i64* @CL_SUCCESS
%625 = icmp ne i64 %623, %624
br i1 %625, label %626, label %629
626: ; preds = %619
%627 = load i64, i64* %29
%628 = call i32 @fatal_CL(i64 %627, i32 666)
br label %629
629: ; preds = %626, %619
%630 = load i32, i32* %47
%631 = bitcast i32* %17 to i8*
%632 = call i64 @clSetKernelArg(i32 %630, i32 2, i32 4, i8* %631)
store i64 %632, i64* %29
%633 = load i64, i64* %29
%634 = load i64, i64* @CL_SUCCESS
%635 = icmp ne i64 %633, %634
br i1 %635, label %636, label %639
636: ; preds = %629
%637 = load i64, i64* %29
%638 = call i32 @fatal_CL(i64 %637, i32 672)
br label %639
639: ; preds = %636, %629
%640 = load i32, i32* %47
%641 = bitcast i64* %18 to i8*
%642 = call i64 @clSetKernelArg(i32 %640, i32 3, i32 8, i8* %641)
store i64 %642, i64* %29
%643 = load i64, i64* %29
%644 = load i64, i64* @CL_SUCCESS
%645 = icmp ne i64 %643, %644
br i1 %645, label %646, label %649
646: ; preds = %639
%647 = load i64, i64* %29
%648 = call i32 @fatal_CL(i64 %647, i32 678)
br label %649
649: ; preds = %646, %639
%650 = load i32, i32* %47
%651 = bitcast i32* %53 to i8*
%652 = call i64 @clSetKernelArg(i32 %650, i32 4, i32 4, i8* %651)
store i64 %652, i64* %29
%653 = load i64, i64* %29
%654 = load i64, i64* @CL_SUCCESS
%655 = icmp ne i64 %653, %654
br i1 %655, label %656, label %659
656: ; preds = %649
%657 = load i64, i64* %29
%658 = call i32 @fatal_CL(i64 %657, i32 684)
br label %659
659: ; preds = %656, %649
%660 = load i32, i32* %47
%661 = bitcast i32* %54 to i8*
%662 = call i64 @clSetKernelArg(i32 %660, i32 5, i32 4, i8* %661)
store i64 %662, i64* %29
%663 = load i64, i64* %29
%664 = load i64, i64* @CL_SUCCESS
%665 = icmp ne i64 %663, %664
br i1 %665, label %666, label %669
666: ; preds = %659
%667 = load i64, i64* %29
%668 = call i32 @fatal_CL(i64 %667, i32 690)
br label %669
669: ; preds = %666, %659
%670 = load i32, i32* %47
%671 = bitcast i32* %55 to i8*
%672 = call i64 @clSetKernelArg(i32 %670, i32 6, i32 4, i8* %671)
store i64 %672, i64* %29
%673 = load i64, i64* %29
%674 = load i64, i64* @CL_SUCCESS
%675 = icmp ne i64 %673, %674
br i1 %675, label %676, label %679
676: ; preds = %669
%677 = load i64, i64* %29
%678 = call i32 @fatal_CL(i64 %677, i32 696)
br label %679
679: ; preds = %676, %669
%680 = load i32, i32* %47
%681 = bitcast i32* %56 to i8*
%682 = call i64 @clSetKernelArg(i32 %680, i32 7, i32 4, i8* %681)
store i64 %682, i64* %29
%683 = load i64, i64* %29
%684 = load i64, i64* @CL_SUCCESS
%685 = icmp ne i64 %683, %684
br i1 %685, label %686, label %689
686: ; preds = %679
%687 = load i64, i64* %29
%688 = call i32 @fatal_CL(i64 %687, i32 702)
br label %689
689: ; preds = %686, %679
%690 = load i32, i32* %47
%691 = bitcast i32* %57 to i8*
%692 = call i64 @clSetKernelArg(i32 %690, i32 8, i32 4, i8* %691)
store i64 %692, i64* %29
%693 = load i64, i64* %29
%694 = load i64, i64* @CL_SUCCESS
%695 = icmp ne i64 %693, %694
br i1 %695, label %696, label %699
696: ; preds = %689
%697 = load i64, i64* %29
%698 = call i32 @fatal_CL(i64 %697, i32 708)
br label %699
699: ; preds = %696, %689
%700 = load i32, i32* %47
%701 = bitcast i32* %58 to i8*
%702 = call i64 @clSetKernelArg(i32 %700, i32 9, i32 4, i8* %701)
store i64 %702, i64* %29
%703 = load i64, i64* %29
%704 = load i64, i64* @CL_SUCCESS
%705 = icmp ne i64 %703, %704
br i1 %705, label %706, label %709
706: ; preds = %699
%707 = load i64, i64* %29
%708 = call i32 @fatal_CL(i64 %707, i32 714)
br label %709
709: ; preds = %706, %699
%710 = load i32, i32* %47
%711 = bitcast i32* %59 to i8*
%712 = call i64 @clSetKernelArg(i32 %710, i32 10, i32 4, i8* %711)
store i64 %712, i64* %29
%713 = load i64, i64* %29
%714 = load i64, i64* @CL_SUCCESS
%715 = icmp ne i64 %713, %714
br i1 %715, label %716, label %719
716: ; preds = %709
%717 = load i64, i64* %29
%718 = call i32 @fatal_CL(i64 %717, i32 720)
br label %719
719: ; preds = %716, %709
%720 = load i32, i32* %47
%721 = bitcast i32* %60 to i8*
%722 = call i64 @clSetKernelArg(i32 %720, i32 11, i32 4, i8* %721)
store i64 %722, i64* %29
%723 = load i64, i64* %29
%724 = load i64, i64* @CL_SUCCESS
%725 = icmp ne i64 %723, %724
br i1 %725, label %726, label %729
726: ; preds = %719
%727 = load i64, i64* %29
%728 = call i32 @fatal_CL(i64 %727, i32 726)
br label %729
729: ; preds = %726, %719
%730 = load i32, i32* %47
%731 = bitcast i32* %61 to i8*
%732 = call i64 @clSetKernelArg(i32 %730, i32 13, i32 4, i8* %731)
store i64 %732, i64* %29
%733 = load i64, i64* %29
%734 = load i64, i64* @CL_SUCCESS
%735 = icmp ne i64 %733, %734
br i1 %735, label %736, label %739
736: ; preds = %729
%737 = load i64, i64* %29
%738 = call i32 @fatal_CL(i64 %737, i32 732)
br label %739
739: ; preds = %736, %729
%740 = load i32, i32* %47
%741 = bitcast i32* %52 to i8*
%742 = call i64 @clSetKernelArg(i32 %740, i32 14, i32 4, i8* %741)
store i64 %742, i64* %29
%743 = load i64, i64* %29
%744 = load i64, i64* @CL_SUCCESS
%745 = icmp ne i64 %743, %744
br i1 %745, label %746, label %749
746: ; preds = %739
%747 = load i64, i64* %29
%748 = call i32 @fatal_CL(i64 %747, i32 738)
br label %749
749: ; preds = %746, %739
%750 = load i32, i32* %48
%751 = bitcast float* %20 to i8*
%752 = call i64 @clSetKernelArg(i32 %750, i32 0, i32 4, i8* %751)
store i64 %752, i64* %29
%753 = load i64, i64* %29
%754 = load i64, i64* @CL_SUCCESS
%755 = icmp ne i64 %753, %754
br i1 %755, label %756, label %759
756: ; preds = %749
%757 = load i64, i64* %29
%758 = call i32 @fatal_CL(i64 %757, i32 749)
br label %759
759: ; preds = %756, %749
%760 = load i32, i32* %48
%761 = bitcast i32* %16 to i8*
%762 = call i64 @clSetKernelArg(i32 %760, i32 1, i32 4, i8* %761)
store i64 %762, i64* %29
%763 = load i64, i64* %29
%764 = load i64, i64* @CL_SUCCESS
%765 = icmp ne i64 %763, %764
br i1 %765, label %766, label %769
766: ; preds = %759
%767 = load i64, i64* %29
%768 = call i32 @fatal_CL(i64 %767, i32 755)
br label %769
769: ; preds = %766, %759
%770 = load i32, i32* %48
%771 = bitcast i32* %17 to i8*
%772 = call i64 @clSetKernelArg(i32 %770, i32 2, i32 4, i8* %771)
store i64 %772, i64* %29
%773 = load i64, i64* %29
%774 = load i64, i64* @CL_SUCCESS
%775 = icmp ne i64 %773, %774
br i1 %775, label %776, label %779
776: ; preds = %769
%777 = load i64, i64* %29
%778 = call i32 @fatal_CL(i64 %777, i32 761)
br label %779
779: ; preds = %776, %769
%780 = load i32, i32* %48
%781 = bitcast i64* %18 to i8*
%782 = call i64 @clSetKernelArg(i32 %780, i32 3, i32 8, i8* %781)
store i64 %782, i64* %29
%783 = load i64, i64* %29
%784 = load i64, i64* @CL_SUCCESS
%785 = icmp ne i64 %783, %784
br i1 %785, label %786, label %789
786: ; preds = %779
%787 = load i64, i64* %29
%788 = call i32 @fatal_CL(i64 %787, i32 767)
br label %789
789: ; preds = %786, %779
%790 = load i32, i32* %48
%791 = bitcast i32* %53 to i8*
%792 = call i64 @clSetKernelArg(i32 %790, i32 4, i32 4, i8* %791)
store i64 %792, i64* %29
%793 = load i64, i64* %29
%794 = load i64, i64* @CL_SUCCESS
%795 = icmp ne i64 %793, %794
br i1 %795, label %796, label %799
796: ; preds = %789
%797 = load i64, i64* %29
%798 = call i32 @fatal_CL(i64 %797, i32 773)
br label %799
799: ; preds = %796, %789
%800 = load i32, i32* %48
%801 = bitcast i32* %54 to i8*
%802 = call i64 @clSetKernelArg(i32 %800, i32 5, i32 4, i8* %801)
store i64 %802, i64* %29
%803 = load i64, i64* %29
%804 = load i64, i64* @CL_SUCCESS
%805 = icmp ne i64 %803, %804
br i1 %805, label %806, label %809
806: ; preds = %799
%807 = load i64, i64* %29
%808 = call i32 @fatal_CL(i64 %807, i32 779)
br label %809
809: ; preds = %806, %799
%810 = load i32, i32* %48
%811 = bitcast i32* %55 to i8*
%812 = call i64 @clSetKernelArg(i32 %810, i32 6, i32 4, i8* %811)
store i64 %812, i64* %29
%813 = load i64, i64* %29
%814 = load i64, i64* @CL_SUCCESS
%815 = icmp ne i64 %813, %814
br i1 %815, label %816, label %819
816: ; preds = %809
%817 = load i64, i64* %29
%818 = call i32 @fatal_CL(i64 %817, i32 785)
br label %819
819: ; preds = %816, %809
%820 = load i32, i32* %48
%821 = bitcast i32* %56 to i8*
%822 = call i64 @clSetKernelArg(i32 %820, i32 7, i32 4, i8* %821)
store i64 %822, i64* %29
%823 = load i64, i64* %29
%824 = load i64, i64* @CL_SUCCESS
%825 = icmp ne i64 %823, %824
br i1 %825, label %826, label %829
826: ; preds = %819
%827 = load i64, i64* %29
%828 = call i32 @fatal_CL(i64 %827, i32 791)
br label %829
829: ; preds = %826, %819
%830 = load i32, i32* %48
%831 = bitcast i32* %57 to i8*
%832 = call i64 @clSetKernelArg(i32 %830, i32 8, i32 4, i8* %831)
store i64 %832, i64* %29
%833 = load i64, i64* %29
%834 = load i64, i64* @CL_SUCCESS
%835 = icmp ne i64 %833, %834
br i1 %835, label %836, label %839
836: ; preds = %829
%837 = load i64, i64* %29
%838 = call i32 @fatal_CL(i64 %837, i32 797)
br label %839
839: ; preds = %836, %829
%840 = load i32, i32* %48
%841 = bitcast i32* %58 to i8*
%842 = call i64 @clSetKernelArg(i32 %840, i32 9, i32 4, i8* %841)
store i64 %842, i64* %29
%843 = load i64, i64* %29
%844 = load i64, i64* @CL_SUCCESS
%845 = icmp ne i64 %843, %844
br i1 %845, label %846, label %849
846: ; preds = %839
%847 = load i64, i64* %29
%848 = call i32 @fatal_CL(i64 %847, i32 803)
br label %849
849: ; preds = %846, %839
%850 = load i32, i32* %48
%851 = bitcast i32* %59 to i8*
%852 = call i64 @clSetKernelArg(i32 %850, i32 10, i32 4, i8* %851)
store i64 %852, i64* %29
%853 = load i64, i64* %29
%854 = load i64, i64* @CL_SUCCESS
%855 = icmp ne i64 %853, %854
br i1 %855, label %856, label %859
856: ; preds = %849
%857 = load i64, i64* %29
%858 = call i32 @fatal_CL(i64 %857, i32 809)
br label %859
859: ; preds = %856, %849
%860 = load i32, i32* %48
%861 = bitcast i32* %60 to i8*
%862 = call i64 @clSetKernelArg(i32 %860, i32 11, i32 4, i8* %861)
store i64 %862, i64* %29
%863 = load i64, i64* %29
%864 = load i64, i64* @CL_SUCCESS
%865 = icmp ne i64 %863, %864
br i1 %865, label %866, label %869
866: ; preds = %859
%867 = load i64, i64* %29
%868 = call i32 @fatal_CL(i64 %867, i32 815)
br label %869
869: ; preds = %866, %859
%870 = load i32, i32* %48
%871 = bitcast i32* %61 to i8*
%872 = call i64 @clSetKernelArg(i32 %870, i32 12, i32 4, i8* %871)
store i64 %872, i64* %29
%873 = load i64, i64* %29
%874 = load i64, i64* @CL_SUCCESS
%875 = icmp ne i64 %873, %874
br i1 %875, label %876, label %879
876: ; preds = %869
%877 = load i64, i64* %29
%878 = call i32 @fatal_CL(i64 %877, i32 821)
br label %879
879: ; preds = %876, %869
%880 = load i32, i32* %48
%881 = bitcast i32* %52 to i8*
%882 = call i64 @clSetKernelArg(i32 %880, i32 13, i32 4, i8* %881)
store i64 %882, i64* %29
%883 = load i64, i64* %29
%884 = load i64, i64* @CL_SUCCESS
%885 = icmp ne i64 %883, %884
br i1 %885, label %886, label %889
886: ; preds = %879
%887 = load i64, i64* %29
%888 = call i32 @fatal_CL(i64 %887, i32 827)
br label %889
889: ; preds = %886, %879
%890 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.16, i64 0, i64 0))
store i32 0, i32* %26
br label %891
891: ; preds = %1069, %889
%892 = load i32, i32* %26
%893 = load i32, i32* %19
%894 = icmp slt i32 %892, %893
br i1 %894, label %895, label %1072
895: ; preds = %891
%896 = load i32, i32* %26
%897 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i64 0, i64 0), i32 %896)
%898 = call i32 @fflush(i32* null)
%899 = load i32, i32* %39
%900 = load i32, i32* %45
%901 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%902 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%903 = call i64 @clEnqueueNDRangeKernel(i32 %899, i32 %900, i32 1, i32* null, i64* %901, i64* %902, i32 0, i32* null, i32* null)
store i64 %903, i64* %29
%904 = load i64, i64* %29
%905 = load i64, i64* @CL_SUCCESS
%906 = icmp ne i64 %904, %905
br i1 %906, label %907, label %910
907: ; preds = %895
%908 = load i64, i64* %29
%909 = call i32 @fatal_CL(i64 %908, i32 860)
br label %910
910: ; preds = %907, %895
%911 = load i32, i32* %65
store i32 %911, i32* %68
%912 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%913 = load i64, i64* %912
%914 = getelementptr inbounds [1 x i64], [1 x i64]* %69, i64 0, i64 0
store i64 %913, i64* %914
%915 = load i64, i64* %18
store i64 %915, i64* %70
store i32 1, i32* %71
br label %916
916: ; preds = %993, %910
%917 = load i32, i32* %68
%918 = icmp ne i32 %917, 0
br i1 %918, label %919, label %994
919: ; preds = %916
%920 = load i32, i32* %46
%921 = bitcast i64* %70 to i8*
%922 = call i64 @clSetKernelArg(i32 %920, i32 1, i32 8, i8* %921)
store i64 %922, i64* %29
%923 = load i64, i64* %29
%924 = load i64, i64* @CL_SUCCESS
%925 = icmp ne i64 %923, %924
br i1 %925, label %926, label %929
926: ; preds = %919
%927 = load i64, i64* %29
%928 = call i32 @fatal_CL(i64 %927, i32 886)
br label %929
929: ; preds = %926, %919
%930 = load i32, i32* %46
%931 = bitcast i32* %71 to i8*
%932 = call i64 @clSetKernelArg(i32 %930, i32 2, i32 4, i8* %931)
store i64 %932, i64* %29
%933 = load i64, i64* %29
%934 = load i64, i64* @CL_SUCCESS
%935 = icmp ne i64 %933, %934
br i1 %935, label %936, label %939
936: ; preds = %929
%937 = load i64, i64* %29
%938 = call i32 @fatal_CL(i64 %937, i32 892)
br label %939
939: ; preds = %936, %929
%940 = load i32, i32* %46
%941 = bitcast i32* %68 to i8*
%942 = call i64 @clSetKernelArg(i32 %940, i32 5, i32 4, i8* %941)
store i64 %942, i64* %29
%943 = load i64, i64* %29
%944 = load i64, i64* @CL_SUCCESS
%945 = icmp ne i64 %943, %944
br i1 %945, label %946, label %949
946: ; preds = %939
%947 = load i64, i64* %29
%948 = call i32 @fatal_CL(i64 %947, i32 899)
br label %949
949: ; preds = %946, %939
%950 = load i32, i32* %39
%951 = load i32, i32* %46
%952 = getelementptr inbounds [1 x i64], [1 x i64]* %69, i64 0, i64 0
%953 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%954 = call i64 @clEnqueueNDRangeKernel(i32 %950, i32 %951, i32 1, i32* null, i64* %952, i64* %953, i32 0, i32* null, i32* null)
store i64 %954, i64* %29
%955 = load i64, i64* %29
%956 = load i64, i64* @CL_SUCCESS
%957 = icmp ne i64 %955, %956
br i1 %957, label %958, label %961
958: ; preds = %949
%959 = load i64, i64* %29
%960 = call i32 @fatal_CL(i64 %959, i32 912)
br label %961
961: ; preds = %958, %949
%962 = load i32, i32* %68
%963 = sext i32 %962 to i64
store i64 %963, i64* %70
%964 = load i32, i32* %68
%965 = icmp eq i32 %964, 1
br i1 %965, label %966, label %967
966: ; preds = %961
store i32 0, i32* %68
br label %993
967: ; preds = %961
%968 = load i32, i32* %71
%969 = mul nsw i32 %968, 128
store i32 %969, i32* %71
%970 = load i32, i32* %68
%971 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%972 = load i64, i64* %971
%973 = trunc i64 %972 to i32
%974 = sdiv i32 %970, %973
store i32 %974, i32* %50
%975 = load i32, i32* %68
%976 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%977 = load i64, i64* %976
%978 = trunc i64 %977 to i32
%979 = srem i32 %975, %978
%980 = icmp ne i32 %979, 0
br i1 %980, label %981, label %984
981: ; preds = %967
%982 = load i32, i32* %50
%983 = add nsw i32 %982, 1
store i32 %983, i32* %50
br label %984
984: ; preds = %981, %967
%985 = load i32, i32* %50
store i32 %985, i32* %68
%986 = load i32, i32* %68
%987 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%988 = load i64, i64* %987
%989 = trunc i64 %988 to i32
%990 = mul nsw i32 %986, %989
%991 = sext i32 %990 to i64
%992 = getelementptr inbounds [1 x i64], [1 x i64]* %69, i64 0, i64 0
store i64 %991, i64* %992
br label %993
993: ; preds = %984, %966
br label %916
994: ; preds = %916
%995 = load i32, i32* %39
%996 = load i32, i32* %62
%997 = load i32, i32* @CL_TRUE
%998 = load i32, i32* %72
%999 = call i64 @clEnqueueReadBuffer(i32 %995, i32 %996, i32 %997, i32 0, i32 %998, float* %73, i32 0, i32* null, i32* null)
store i64 %999, i64* %29
%1000 = load i64, i64* %29
%1001 = load i64, i64* @CL_SUCCESS
%1002 = icmp ne i64 %1000, %1001
br i1 %1002, label %1003, label %1006
1003: ; preds = %994
%1004 = load i64, i64* %29
%1005 = call i32 @fatal_CL(i64 %1004, i32 947)
br label %1006
1006: ; preds = %1003, %994
%1007 = load i32, i32* %39
%1008 = load i32, i32* %63
%1009 = load i32, i32* @CL_TRUE
%1010 = load i32, i32* %72
%1011 = call i64 @clEnqueueReadBuffer(i32 %1007, i32 %1008, i32 %1009, i32 0, i32 %1010, float* %74, i32 0, i32* null, i32* null)
store i64 %1011, i64* %29
%1012 = load i64, i64* %29
%1013 = load i64, i64* @CL_SUCCESS
%1014 = icmp ne i64 %1012, %1013
br i1 %1014, label %1015, label %1018
1015: ; preds = %1006
%1016 = load i64, i64* %29
%1017 = call i32 @fatal_CL(i64 %1016, i32 959)
br label %1018
1018: ; preds = %1015, %1006
%1019 = load float, float* %73
%1020 = load i64, i64* %21
%1021 = sitofp i64 %1020 to float
%1022 = fdiv float %1019, %1021
store float %1022, float* %75
%1023 = load float, float* %75
%1024 = load float, float* %75
%1025 = fmul float %1023, %1024
store float %1025, float* %76
%1026 = load float, float* %74
%1027 = load i64, i64* %21
%1028 = sitofp i64 %1027 to float
%1029 = fdiv float %1026, %1028
%1030 = load float, float* %76
%1031 = fsub float %1029, %1030
store float %1031, float* %77
%1032 = load float, float* %77
%1033 = load float, float* %76
%1034 = fdiv float %1032, %1033
store float %1034, float* %78
%1035 = load i32, i32* %47
%1036 = bitcast float* %78 to i8*
%1037 = call i64 @clSetKernelArg(i32 %1035, i32 12, i32 4, i8* %1036)
store i64 %1037, i64* %29
%1038 = load i64, i64* %29
%1039 = load i64, i64* @CL_SUCCESS
%1040 = icmp ne i64 %1038, %1039
br i1 %1040, label %1041, label %1044
1041: ; preds = %1018
%1042 = load i64, i64* %29
%1043 = call i32 @fatal_CL(i64 %1042, i32 980)
br label %1044
1044: ; preds = %1041, %1018
%1045 = load i32, i32* %39
%1046 = load i32, i32* %47
%1047 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%1048 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%1049 = call i64 @clEnqueueNDRangeKernel(i32 %1045, i32 %1046, i32 1, i32* null, i64* %1047, i64* %1048, i32 0, i32* null, i32* null)
store i64 %1049, i64* %29
%1050 = load i64, i64* %29
%1051 = load i64, i64* @CL_SUCCESS
%1052 = icmp ne i64 %1050, %1051
br i1 %1052, label %1053, label %1056
1053: ; preds = %1044
%1054 = load i64, i64* %29
%1055 = call i32 @fatal_CL(i64 %1054, i32 993)
br label %1056
1056: ; preds = %1053, %1044
%1057 = load i32, i32* %39
%1058 = load i32, i32* %48
%1059 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%1060 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%1061 = call i64 @clEnqueueNDRangeKernel(i32 %1057, i32 %1058, i32 1, i32* null, i64* %1059, i64* %1060, i32 0, i32* null, i32* null)
store i64 %1061, i64* %29
%1062 = load i64, i64* %29
%1063 = load i64, i64* @CL_SUCCESS
%1064 = icmp ne i64 %1062, %1063
br i1 %1064, label %1065, label %1068
1065: ; preds = %1056
%1066 = load i64, i64* %29
%1067 = call i32 @fatal_CL(i64 %1066, i32 1015)
br label %1068
1068: ; preds = %1065, %1056
br label %1069
1069: ; preds = %1068
%1070 = load i32, i32* %26
%1071 = add nsw i32 %1070, 1
store i32 %1071, i32* %26
br label %891
1072: ; preds = %891
%1073 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
%1074 = load i32, i32* %49
%1075 = bitcast i64* %18 to i8*
%1076 = call i64 @clSetKernelArg(i32 %1074, i32 0, i32 8, i8* %1075)
store i64 %1076, i64* %29
%1077 = load i64, i64* %29
%1078 = load i64, i64* @CL_SUCCESS
%1079 = icmp ne i64 %1077, %1078
br i1 %1079, label %1080, label %1083
1080: ; preds = %1072
%1081 = load i64, i64* %29
%1082 = call i32 @fatal_CL(i64 %1081, i32 1043)
br label %1083
1083: ; preds = %1080, %1072
%1084 = load i32, i32* %49
%1085 = bitcast i32* %52 to i8*
%1086 = call i64 @clSetKernelArg(i32 %1084, i32 1, i32 4, i8* %1085)
store i64 %1086, i64* %29
%1087 = load i64, i64* %29
%1088 = load i64, i64* @CL_SUCCESS
%1089 = icmp ne i64 %1087, %1088
br i1 %1089, label %1090, label %1093
1090: ; preds = %1083
%1091 = load i64, i64* %29
%1092 = call i32 @fatal_CL(i64 %1091, i32 1049)
br label %1093
1093: ; preds = %1090, %1083
%1094 = load i32, i32* %39
%1095 = load i32, i32* %49
%1096 = getelementptr inbounds [1 x i64], [1 x i64]* %66, i64 0, i64 0
%1097 = getelementptr inbounds [1 x i64], [1 x i64]* %64, i64 0, i64 0
%1098 = call i64 @clEnqueueNDRangeKernel(i32 %1094, i32 %1095, i32 1, i32* null, i64* %1096, i64* %1097, i32 0, i32* null, i32* null)
store i64 %1098, i64* %29
%1099 = load i64, i64* %29
%1100 = load i64, i64* @CL_SUCCESS
%1101 = icmp ne i64 %1099, %1100
br i1 %1101, label %1102, label %1105
1102: ; preds = %1093
%1103 = load i64, i64* %29
%1104 = call i32 @fatal_CL(i64 %1103, i32 1065)
br label %1105
1105: ; preds = %1102, %1093
%1106 = load i32, i32* %39
%1107 = call i64 @clFinish(i32 %1106)
store i64 %1107, i64* %29
%1108 = load i64, i64* %29
%1109 = load i64, i64* @CL_SUCCESS
%1110 = icmp ne i64 %1108, %1109
br i1 %1110, label %1111, label %1114
1111: ; preds = %1105
%1112 = load i64, i64* %29
%1113 = call i32 @fatal_CL(i64 %1112, i32 1073)
br label %1114
1114: ; preds = %1111, %1105
%1115 = load i32, i32* %39
%1116 = load i32, i32* %52
%1117 = load i32, i32* @CL_TRUE
%1118 = load i32, i32* %51
%1119 = load float*, float** %15
%1120 = call i64 @clEnqueueReadBuffer(i32 %1115, i32 %1116, i32 %1117, i32 0, i32 %1118, float* %1119, i32 0, i32* null, i32* null)
store i64 %1120, i64* %29
%1121 = load i64, i64* %29
%1122 = load i64, i64* @CL_SUCCESS
%1123 = icmp ne i64 %1121, %1122
br i1 %1123, label %1124, label %1127
1124: ; preds = %1114
%1125 = load i64, i64* %29
%1126 = call i32 @fatal_CL(i64 %1125, i32 1093)
br label %1127
1127: ; preds = %1124, %1114
%1128 = load i32, i32* %44
%1129 = call i64 @clReleaseKernel(i32 %1128)
store i64 %1129, i64* %29
%1130 = load i64, i64* %29
%1131 = load i64, i64* @CL_SUCCESS
%1132 = icmp ne i64 %1130, %1131
br i1 %1132, label %1133, label %1136
1133: ; preds = %1127
%1134 = load i64, i64* %29
%1135 = call i32 @fatal_CL(i64 %1134, i32 1107)
br label %1136
1136: ; preds = %1133, %1127
%1137 = load i32, i32* %45
%1138 = call i64 @clReleaseKernel(i32 %1137)
store i64 %1138, i64* %29
%1139 = load i64, i64* %29
%1140 = load i64, i64* @CL_SUCCESS
%1141 = icmp ne i64 %1139, %1140
br i1 %1141, label %1142, label %1145
1142: ; preds = %1136
%1143 = load i64, i64* %29
%1144 = call i32 @fatal_CL(i64 %1143, i32 1110)
br label %1145
1145: ; preds = %1142, %1136
%1146 = load i32, i32* %46
%1147 = call i64 @clReleaseKernel(i32 %1146)
store i64 %1147, i64* %29
%1148 = load i64, i64* %29
%1149 = load i64, i64* @CL_SUCCESS
%1150 = icmp ne i64 %1148, %1149
br i1 %1150, label %1151, label %1154
1151: ; preds = %1145
%1152 = load i64, i64* %29
%1153 = call i32 @fatal_CL(i64 %1152, i32 1113)
br label %1154
1154: ; preds = %1151, %1145
%1155 = load i32, i32* %47
%1156 = call i64 @clReleaseKernel(i32 %1155)
store i64 %1156, i64* %29
%1157 = load i64, i64* %29
%1158 = load i64, i64* @CL_SUCCESS
%1159 = icmp ne i64 %1157, %1158
br i1 %1159, label %1160, label %1163
1160: ; preds = %1154
%1161 = load i64, i64* %29
%1162 = call i32 @fatal_CL(i64 %1161, i32 1116)
br label %1163
1163: ; preds = %1160, %1154
%1164 = load i32, i32* %48
%1165 = call i64 @clReleaseKernel(i32 %1164)
store i64 %1165, i64* %29
%1166 = load i64, i64* %29
%1167 = load i64, i64* @CL_SUCCESS
%1168 = icmp ne i64 %1166, %1167
br i1 %1168, label %1169, label %1172
1169: ; preds = %1163
%1170 = load i64, i64* %29
%1171 = call i32 @fatal_CL(i64 %1170, i32 1119)
br label %1172
1172: ; preds = %1169, %1163
%1173 = load i32, i32* %49
%1174 = call i64 @clReleaseKernel(i32 %1173)
store i64 %1174, i64* %29
%1175 = load i64, i64* %29
%1176 = load i64, i64* @CL_SUCCESS
%1177 = icmp ne i64 %1175, %1176
br i1 %1177, label %1178, label %1181
1178: ; preds = %1172
%1179 = load i64, i64* %29
%1180 = call i32 @fatal_CL(i64 %1179, i32 1122)
br label %1181
1181: ; preds = %1178, %1172
%1182 = load i32, i32* %42
%1183 = call i64 @clReleaseProgram(i32 %1182)
store i64 %1183, i64* %29
%1184 = load i64, i64* %29
%1185 = load i64, i64* @CL_SUCCESS
%1186 = icmp ne i64 %1184, %1185
br i1 %1186, label %1187, label %1190
1187: ; preds = %1181
%1188 = load i64, i64* %29
%1189 = call i32 @fatal_CL(i64 %1188, i32 1125)
br label %1190
1190: ; preds = %1187, %1181
%1191 = load i32, i32* %52
%1192 = call i64 @clReleaseMemObject(i32 %1191)
store i64 %1192, i64* %29
%1193 = load i64, i64* %29
%1194 = load i64, i64* @CL_SUCCESS
%1195 = icmp ne i64 %1193, %1194
br i1 %1195, label %1196, label %1199
1196: ; preds = %1190
%1197 = load i64, i64* %29
%1198 = call i32 @fatal_CL(i64 %1197, i32 1130)
br label %1199
1199: ; preds = %1196, %1190
%1200 = load i32, i32* %61
%1201 = call i64 @clReleaseMemObject(i32 %1200)
store i64 %1201, i64* %29
%1202 = load i64, i64* %29
%1203 = load i64, i64* @CL_SUCCESS
%1204 = icmp ne i64 %1202, %1203
br i1 %1204, label %1205, label %1208
1205: ; preds = %1199
%1206 = load i64, i64* %29
%1207 = call i32 @fatal_CL(i64 %1206, i32 1133)
br label %1208
1208: ; preds = %1205, %1199
%1209 = load i32, i32* %53
%1210 = call i64 @clReleaseMemObject(i32 %1209)
store i64 %1210, i64* %29
%1211 = load i64, i64* %29
%1212 = load i64, i64* @CL_SUCCESS
%1213 = icmp ne i64 %1211, %1212
br i1 %1213, label %1214, label %1217
1214: ; preds = %1208
%1215 = load i64, i64* %29
%1216 = call i32 @fatal_CL(i64 %1215, i32 1137)
br label %1217
1217: ; preds = %1214, %1208
%1218 = load i32, i32* %54
%1219 = call i64 @clReleaseMemObject(i32 %1218)
store i64 %1219, i64* %29
%1220 = load i64, i64* %29
%1221 = load i64, i64* @CL_SUCCESS
%1222 = icmp ne i64 %1220, %1221
br i1 %1222, label %1223, label %1226
1223: ; preds = %1217
%1224 = load i64, i64* %29
%1225 = call i32 @fatal_CL(i64 %1224, i32 1140)
br label %1226
1226: ; preds = %1223, %1217
%1227 = load i32, i32* %55
%1228 = call i64 @clReleaseMemObject(i32 %1227)
store i64 %1228, i64* %29
%1229 = load i64, i64* %29
%1230 = load i64, i64* @CL_SUCCESS
%1231 = icmp ne i64 %1229, %1230
br i1 %1231, label %1232, label %1235
1232: ; preds = %1226
%1233 = load i64, i64* %29
%1234 = call i32 @fatal_CL(i64 %1233, i32 1143)
br label %1235
1235: ; preds = %1232, %1226
%1236 = load i32, i32* %56
%1237 = call i64 @clReleaseMemObject(i32 %1236)
store i64 %1237, i64* %29
%1238 = load i64, i64* %29
%1239 = load i64, i64* @CL_SUCCESS
%1240 = icmp ne i64 %1238, %1239
br i1 %1240, label %1241, label %1244
1241: ; preds = %1235
%1242 = load i64, i64* %29
%1243 = call i32 @fatal_CL(i64 %1242, i32 1146)
br label %1244
1244: ; preds = %1241, %1235
%1245 = load i32, i32* %57
%1246 = call i64 @clReleaseMemObject(i32 %1245)
store i64 %1246, i64* %29
%1247 = load i64, i64* %29
%1248 = load i64, i64* @CL_SUCCESS
%1249 = icmp ne i64 %1247, %1248
br i1 %1249, label %1250, label %1253
1250: ; preds = %1244
%1251 = load i64, i64* %29
%1252 = call i32 @fatal_CL(i64 %1251, i32 1150)
br label %1253
1253: ; preds = %1250, %1244
%1254 = load i32, i32* %58
%1255 = call i64 @clReleaseMemObject(i32 %1254)
store i64 %1255, i64* %29
%1256 = load i64, i64* %29
%1257 = load i64, i64* @CL_SUCCESS
%1258 = icmp ne i64 %1256, %1257
br i1 %1258, label %1259, label %1262
1259: ; preds = %1253
%1260 = load i64, i64* %29
%1261 = call i32 @fatal_CL(i64 %1260, i32 1153)
br label %1262
1262: ; preds = %1259, %1253
%1263 = load i32, i32* %60
%1264 = call i64 @clReleaseMemObject(i32 %1263)
store i64 %1264, i64* %29
%1265 = load i64, i64* %29
%1266 = load i64, i64* @CL_SUCCESS
%1267 = icmp ne i64 %1265, %1266
br i1 %1267, label %1268, label %1271
1268: ; preds = %1262
%1269 = load i64, i64* %29
%1270 = call i32 @fatal_CL(i64 %1269, i32 1156)
br label %1271
1271: ; preds = %1268, %1262
%1272 = load i32, i32* %59
%1273 = call i64 @clReleaseMemObject(i32 %1272)
store i64 %1273, i64* %29
%1274 = load i64, i64* %29
%1275 = load i64, i64* @CL_SUCCESS
%1276 = icmp ne i64 %1274, %1275
br i1 %1276, label %1277, label %1280
1277: ; preds = %1271
%1278 = load i64, i64* %29
%1279 = call i32 @fatal_CL(i64 %1278, i32 1159)
br label %1280
1280: ; preds = %1277, %1271
%1281 = load i32, i32* %62
%1282 = call i64 @clReleaseMemObject(i32 %1281)
store i64 %1282, i64* %29
%1283 = load i64, i64* %29
%1284 = load i64, i64* @CL_SUCCESS
%1285 = icmp ne i64 %1283, %1284
br i1 %1285, label %1286, label %1289
1286: ; preds = %1280
%1287 = load i64, i64* %29
%1288 = call i32 @fatal_CL(i64 %1287, i32 1163)
br label %1289
1289: ; preds = %1286, %1280
%1290 = load i32, i32* %63
%1291 = call i64 @clReleaseMemObject(i32 %1290)
store i64 %1291, i64* %29
%1292 = load i64, i64* %29
%1293 = load i64, i64* @CL_SUCCESS
%1294 = icmp ne i64 %1292, %1293
br i1 %1294, label %1295, label %1298
1295: ; preds = %1289
%1296 = load i64, i64* %29
%1297 = call i32 @fatal_CL(i64 %1296, i32 1166)
br label %1298
1298: ; preds = %1295, %1289
%1299 = load i32, i32* %39
%1300 = call i64 @clFlush(i32 %1299)
store i64 %1300, i64* %29
%1301 = load i64, i64* %29
%1302 = load i64, i64* @CL_SUCCESS
%1303 = icmp ne i64 %1301, %1302
br i1 %1303, label %1304, label %1307
1304: ; preds = %1298
%1305 = load i64, i64* %29
%1306 = call i32 @fatal_CL(i64 %1305, i32 1171)
br label %1307
1307: ; preds = %1304, %1298
%1308 = load i32, i32* %39
%1309 = call i64 @clReleaseCommandQueue(i32 %1308)
store i64 %1309, i64* %29
%1310 = load i64, i64* %29
%1311 = load i64, i64* @CL_SUCCESS
%1312 = icmp ne i64 %1310, %1311
br i1 %1312, label %1313, label %1316
1313: ; preds = %1307
%1314 = load i64, i64* %29
%1315 = call i32 @fatal_CL(i64 %1314, i32 1174)
br label %1316
1316: ; preds = %1313, %1307
%1317 = load i32, i32* %35
%1318 = call i64 @clReleaseContext(i32 %1317)
store i64 %1318, i64* %29
%1319 = load i64, i64* %29
%1320 = load i64, i64* @CL_SUCCESS
%1321 = icmp ne i64 %1319, %1320
br i1 %1321, label %1322, label %1325
1322: ; preds = %1316
%1323 = load i64, i64* %29
%1324 = call i32 @fatal_CL(i64 %1323, i32 1177)
br label %1325
1325: ; preds = %1322, %1316
ret void
}

LLVM IR (-O2):
@CL_SUCCESS = global i64 0
@CL_PLATFORM_VENDOR = global i32 0
@.str = [14 x i8] c"Platform: %s\0A\00"
@CL_CONTEXT_PLATFORM = global i32 0
@CL_DEVICE_TYPE_ALL = global i32 0
@CL_CONTEXT_DEVICES = global i32 0
@CL_DEVICE_NAME = global i32 0
@.str.1 = [12 x i8] c"Device: %s\0A\00"
@.str.2 = [30 x i8] c"./kernel/kernel_gpu_opencl.cl\00"
@kernel_gpu_opencl_wrapper.log = internal global [65536 x i8] zeroinitializer
@CL_PROGRAM_BUILD_LOG = global i32 0
@.str.5 = [9 x i8] c"warning:\00"
@.str.6 = [7 x i8] c"error:\00"
@.str.7 = [14 x i8] c"<<<<\0A%s\0A>>>>\0A\00"
@.str.9 = [15 x i8] c"extract_kernel\00"
@.str.10 = [15 x i8] c"prepare_kernel\00"
@.str.11 = [14 x i8] c"reduce_kernel\00"
@.str.12 = [12 x i8] c"srad_kernel\00"
@.str.13 = [13 x i8] c"srad2_kernel\00"
@.str.14 = [16 x i8] c"compress_kernel\00"
@CL_MEM_READ_WRITE = global i32 0
@.str.15 = [87 x i8] c"max # of workgroups = %d, # of threads/workgroup = %d (ensure that device can handle)\0A\00"
@.str.16 = [22 x i8] c"Iterations Progress: \00"
@.str.17 = [4 x i8] c"%d \00"
@CL_TRUE = global i32 0
@str = [33 x i8] c"-----OpenCL Compiler Output-----\00"
@str.19 = [33 x i8] c"--------------------------------\00"
define void @kernel_gpu_opencl_wrapper(float* %0, i32 %1, i32 %2, i64 %3, i32 %4, float %5, i64 %6, i32* %7, i32* %8, i32* %9, i32* %10, i32 %11, i32 %12, i32 %13) {
%15 = alloca i32
%16 = alloca i32
%17 = alloca i64
%18 = alloca float
%19 = alloca i64
%20 = alloca i32
%21 = alloca [100 x i8]
%22 = alloca [3 x i32]
%23 = alloca i64
%24 = alloca i32
%25 = alloca i8*
%26 = alloca i64
%27 = alloca [150 x i8]
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca [1 x i64]
%41 = alloca [1 x i64]
%42 = alloca i32
%43 = alloca [1 x i64]
%44 = alloca i64
%45 = alloca i32
%46 = alloca float
%47 = alloca float
%48 = alloca float
store i32 %1, i32* %15
store i32 %2, i32* %16
store i64 %3, i64* %17
store float %5, float* %18
%49 = bitcast i64* %19 to i8*
%50 = bitcast i32* %20 to i8*
%51 = call i64 @clGetPlatformIDs(i32 0, i32* null, i32* %20)
store i64 %51, i64* %19
%52 = load i64, i64* @CL_SUCCESS
%53 = icmp eq i64 %51, %52
br i1 %53, label %56, label %54
54: ; preds = %14
%55 = call i32 @fatal_CL(i64 %51, i32 82)
br label %56
56: ; preds = %54, %14
%57 = load i32, i32* %20
%58 = sext i32 %57 to i64
%59 = shl nsw i64 %58, 2
%60 = call i64 @malloc(i64 %59)
%61 = inttoptr i64 %60 to i32*
%62 = load i32, i32* %20
%63 = call i64 @clGetPlatformIDs(i32 %62, i32* %61, i32* null)
store i64 %63, i64* %19
%64 = load i64, i64* @CL_SUCCESS
%65 = icmp eq i64 %63, %64
br i1 %65, label %68, label %66
66: ; preds = %56
%67 = call i32 @fatal_CL(i64 %63, i32 90)
br label %68
68: ; preds = %66, %56
%69 = load i32, i32* %61
%70 = getelementptr inbounds [100 x i8], [100 x i8]* %21, i64 0, i64 0
%71 = load i32, i32* @CL_PLATFORM_VENDOR
%72 = call i64 @clGetPlatformInfo(i32 %69, i32 %71, i32 100, i8* %70, i32* null)
store i64 %72, i64* %19
%73 = load i64, i64* @CL_SUCCESS
%74 = icmp eq i64 %72, %73
br i1 %74, label %77, label %75
75: ; preds = %68
%76 = call i32 @fatal_CL(i64 %72, i32 103)
br label %77
77: ; preds = %75, %68
%78 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i8* %70)
%79 = bitcast [3 x i32]* %22 to i8*
%80 = getelementptr inbounds [3 x i32], [3 x i32]* %22, i64 0, i64 0
%81 = load i32, i32* @CL_CONTEXT_PLATFORM
store i32 %81, i32* %80
%82 = getelementptr inbounds [3 x i32], [3 x i32]* %22, i64 0, i64 1
store i32 %69, i32* %82
%83 = getelementptr inbounds [3 x i32], [3 x i32]* %22, i64 0, i64 2
store i32 0, i32* %83
%84 = load i32, i32* @CL_DEVICE_TYPE_ALL
%85 = call i32 @clCreateContextFromType(i32* %80, i32 %84, i32* null, i32* null, i64* %19)
%86 = load i64, i64* %19
%87 = load i64, i64* @CL_SUCCESS
%88 = icmp eq i64 %86, %87
br i1 %88, label %91, label %89
89: ; preds = %77
%90 = call i32 @fatal_CL(i64 %86, i32 123)
br label %91
91: ; preds = %89, %77
%92 = bitcast i64* %23 to i8*
%93 = load i32, i32* @CL_CONTEXT_DEVICES
%94 = call i64 @clGetContextInfo(i32 %85, i32 %93, i64 0, i32* null, i64* %23)
store i64 %94, i64* %19
%95 = load i64, i64* @CL_SUCCESS
%96 = icmp eq i64 %94, %95
br i1 %96, label %99, label %97
97: ; preds = %91
%98 = call i32 @fatal_CL(i64 %94, i32 137)
br label %99
99: ; preds = %97, %91
%100 = load i64, i64* %23
%101 = call i64 @malloc(i64 %100)
%102 = inttoptr i64 %101 to i32*
%103 = load i32, i32* @CL_CONTEXT_DEVICES
%104 = load i64, i64* %23
%105 = call i64 @clGetContextInfo(i32 %85, i32 %103, i64 %104, i32* %102, i64* null)
store i64 %105, i64* %19
%106 = load i64, i64* @CL_SUCCESS
%107 = icmp eq i64 %105, %106
br i1 %107, label %110, label %108
108: ; preds = %99
%109 = call i32 @fatal_CL(i64 %105, i32 147)
br label %110
110: ; preds = %108, %99
%111 = bitcast i32* %24 to i8*
%112 = load i32, i32* %102
store i32 %112, i32* %24
%113 = load i32, i32* @CL_DEVICE_NAME
%114 = call i64 @clGetDeviceInfo(i32 %112, i32 %113, i32 100, i8* %70, i32* null)
store i64 %114, i64* %19
%115 = load i64, i64* @CL_SUCCESS
%116 = icmp eq i64 %114, %115
br i1 %116, label %119, label %117
117: ; preds = %110
%118 = call i32 @fatal_CL(i64 %114, i32 160)
br label %119
119: ; preds = %117, %110
%120 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i8* %70)
%121 = load i32, i32* %24
%122 = call i32 @clCreateCommandQueue(i32 %85, i32 %121, i32 0, i64* %19)
%123 = load i64, i64* %19
%124 = load i64, i64* @CL_SUCCESS
%125 = icmp eq i64 %123, %124
br i1 %125, label %128, label %126
126: ; preds = %119
%127 = call i32 @fatal_CL(i64 %123, i32 174)
br label %128
128: ; preds = %126, %119
%129 = bitcast i8** %25 to i8*
%130 = call i8* @load_kernel_source(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0))
store i8* %130, i8** %25
%131 = bitcast i64* %26 to i8*
%132 = call i64 @strlen(i8* dereferenceable(1) %130)
store i64 %132, i64* %26
%133 = call i32 @clCreateProgramWithSource(i32 %85, i32 1, i8** %25, i64* %26, i64* %19)
%134 = load i64, i64* %19
%135 = load i64, i64* @CL_SUCCESS
%136 = icmp eq i64 %134, %135
br i1 %136, label %139, label %137
137: ; preds = %128
%138 = call i32 @fatal_CL(i64 %134, i32 191)
br label %139
139: ; preds = %137, %128
%140 = getelementptr inbounds [150 x i8], [150 x i8]* %27, i64 0, i64 0
%141 = bitcast [150 x i8]* %27 to i32*
store i32 3033389, i32* %141
%142 = call i64 @clBuildProgram(i32 %133, i32 1, i32* %24, i8* %140, i32* null, i32* null)
store i64 %142, i64* %19
%143 = call i32 @memset(i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i32 0, i32 65536)
%144 = load i32, i32* %24
%145 = load i32, i32* @CL_PROGRAM_BUILD_LOG
%146 = call i32 @clGetProgramBuildInfo(i32 %133, i32 %144, i32 %145, i32 65535, i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i32* null)
%147 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%148 = call i64 @strstr(i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%149 = icmp eq i64 %148, 0
br i1 %149, label %150, label %153
150: ; preds = %139
%151 = call i64 @strstr(i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0))
%152 = icmp eq i64 %151, 0
br i1 %152, label %155, label %153
153: ; preds = %150, %139
%154 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([65536 x i8], [65536 x i8]* @kernel_gpu_opencl_wrapper.log, i64 0, i64 0))
br label %155
155: ; preds = %153, %150
%156 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.19, i64 0, i64 0))
%157 = load i64, i64* %19
%158 = load i64, i64* @CL_SUCCESS
%159 = icmp eq i64 %157, %158
br i1 %159, label %162, label %160
160: ; preds = %155
%161 = call i32 @fatal_CL(i64 %157, i32 227)
br label %162
162: ; preds = %160, %155
%163 = call i32 @clCreateKernel(i32 %133, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0), i64* %19)
%164 = load i64, i64* %19
%165 = load i64, i64* @CL_SUCCESS
%166 = icmp eq i64 %164, %165
br i1 %166, label %169, label %167
167: ; preds = %162
%168 = call i32 @fatal_CL(i64 %164, i32 239)
br label %169
169: ; preds = %167, %162
%170 = call i32 @clCreateKernel(i32 %133, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), i64* %19)
%171 = load i64, i64* %19
%172 = load i64, i64* @CL_SUCCESS
%173 = icmp eq i64 %171, %172
br i1 %173, label %176, label %174
174: ; preds = %169
%175 = call i32 @fatal_CL(i64 %171, i32 247)
br label %176
176: ; preds = %174, %169
%177 = call i32 @clCreateKernel(i32 %133, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.11, i64 0, i64 0), i64* %19)
%178 = load i64, i64* %19
%179 = load i64, i64* @CL_SUCCESS
%180 = icmp eq i64 %178, %179
br i1 %180, label %183, label %181
181: ; preds = %176
%182 = call i32 @fatal_CL(i64 %178, i32 255)
br label %183
183: ; preds = %181, %176
%184 = call i32 @clCreateKernel(i32 %133, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0), i64* %19)
%185 = load i64, i64* %19
%186 = load i64, i64* @CL_SUCCESS
%187 = icmp eq i64 %185, %186
br i1 %187, label %190, label %188
188: ; preds = %183
%189 = call i32 @fatal_CL(i64 %185, i32 263)
br label %190
190: ; preds = %188, %183
%191 = call i32 @clCreateKernel(i32 %133, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.13, i64 0, i64 0), i64* %19)
%192 = load i64, i64* %19
%193 = load i64, i64* @CL_SUCCESS
%194 = icmp eq i64 %192, %193
br i1 %194, label %197, label %195
195: ; preds = %190
%196 = call i32 @fatal_CL(i64 %192, i32 271)
br label %197
197: ; preds = %195, %190
%198 = call i32 @clCreateKernel(i32 %133, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.14, i64 0, i64 0), i64* %19)
%199 = load i64, i64* %19
%200 = load i64, i64* @CL_SUCCESS
%201 = icmp eq i64 %199, %200
br i1 %201, label %204, label %202
202: ; preds = %197
%203 = call i32 @fatal_CL(i64 %199, i32 279)
br label %204
204: ; preds = %202, %197
%205 = load i64, i64* %17
%206 = trunc i64 %205 to i32
%207 = shl i32 %206, 2
%208 = bitcast i32* %28 to i8*
%209 = load i32, i32* @CL_MEM_READ_WRITE
%210 = call i32 @clCreateBuffer(i32 %85, i32 %209, i32 %207, i32* null, i64* %19)
store i32 %210, i32* %28
%211 = load i64, i64* %19
%212 = load i64, i64* @CL_SUCCESS
%213 = icmp eq i64 %211, %212
br i1 %213, label %216, label %214
214: ; preds = %204
%215 = call i32 @fatal_CL(i64 %211, i32 316)
br label %216
216: ; preds = %214, %204
%217 = bitcast i32* %29 to i8*
%218 = load i32, i32* @CL_MEM_READ_WRITE
%219 = call i32 @clCreateBuffer(i32 %85, i32 %218, i32 %12, i32* null, i64* %19)
store i32 %219, i32* %29
%220 = load i64, i64* %19
%221 = load i64, i64* @CL_SUCCESS
%222 = icmp eq i64 %220, %221
br i1 %222, label %225, label %223
223: ; preds = %216
%224 = call i32 @fatal_CL(i64 %220, i32 329)
br label %225
225: ; preds = %223, %216
%226 = bitcast i32* %30 to i8*
%227 = load i32, i32* @CL_MEM_READ_WRITE
%228 = call i32 @clCreateBuffer(i32 %85, i32 %227, i32 %12, i32* null, i64* %19)
store i32 %228, i32* %30
%229 = load i64, i64* %19
%230 = load i64, i64* @CL_SUCCESS
%231 = icmp eq i64 %229, %230
br i1 %231, label %234, label %232
232: ; preds = %225
%233 = call i32 @fatal_CL(i64 %229, i32 338)
br label %234
234: ; preds = %232, %225
%235 = bitcast i32* %31 to i8*
%236 = load i32, i32* @CL_MEM_READ_WRITE
%237 = call i32 @clCreateBuffer(i32 %85, i32 %236, i32 %13, i32* null, i64* %19)
store i32 %237, i32* %31
%238 = load i64, i64* %19
%239 = load i64, i64* @CL_SUCCESS
%240 = icmp eq i64 %238, %239
br i1 %240, label %243, label %241
241: ; preds = %234
%242 = call i32 @fatal_CL(i64 %238, i32 347)
br label %243
243: ; preds = %241, %234
%244 = bitcast i32* %32 to i8*
%245 = load i32, i32* @CL_MEM_READ_WRITE
%246 = call i32 @clCreateBuffer(i32 %85, i32 %245, i32 %13, i32* null, i64* %19)
store i32 %246, i32* %32
%247 = load i64, i64* %19
%248 = load i64, i64* @CL_SUCCESS
%249 = icmp eq i64 %247, %248
br i1 %249, label %252, label %250
250: ; preds = %243
%251 = call i32 @fatal_CL(i64 %247, i32 356)
br label %252
252: ; preds = %250, %243
%253 = bitcast i32* %33 to i8*
%254 = load i32, i32* @CL_MEM_READ_WRITE
%255 = call i32 @clCreateBuffer(i32 %85, i32 %254, i32 %207, i32* null, i64* %19)
store i32 %255, i32* %33
%256 = load i64, i64* %19
%257 = load i64, i64* @CL_SUCCESS
%258 = icmp eq i64 %256, %257
br i1 %258, label %261, label %259
259: ; preds = %252
%260 = call i32 @fatal_CL(i64 %256, i32 369)
br label %261
261: ; preds = %259, %252
%262 = bitcast i32* %34 to i8*
%263 = load i32, i32* @CL_MEM_READ_WRITE
%264 = call i32 @clCreateBuffer(i32 %85, i32 %263, i32 %207, i32* null, i64* %19)
store i32 %264, i32* %34
%265 = load i64, i64* %19
%266 = load i64, i64* @CL_SUCCESS
%267 = icmp eq i64 %265, %266
br i1 %267, label %270, label %268
268: ; preds = %261
%269 = call i32 @fatal_CL(i64 %265, i32 378)
br label %270
270: ; preds = %268, %261
%271 = bitcast i32* %35 to i8*
%272 = load i32, i32* @CL_MEM_READ_WRITE
%273 = call i32 @clCreateBuffer(i32 %85, i32 %272, i32 %207, i32* null, i64* %19)
store i32 %273, i32* %35
%274 = load i64, i64* %19
%275 = load i64, i64* @CL_SUCCESS
%276 = icmp eq i64 %274, %275
br i1 %276, label %279, label %277
277: ; preds = %270
%278 = call i32 @fatal_CL(i64 %274, i32 387)
br label %279
279: ; preds = %277, %270
%280 = bitcast i32* %36 to i8*
%281 = load i32, i32* @CL_MEM_READ_WRITE
%282 = call i32 @clCreateBuffer(i32 %85, i32 %281, i32 %207, i32* null, i64* %19)
store i32 %282, i32* %36
%283 = load i64, i64* %19
%284 = load i64, i64* @CL_SUCCESS
%285 = icmp eq i64 %283, %284
br i1 %285, label %288, label %286
286: ; preds = %279
%287 = call i32 @fatal_CL(i64 %283, i32 396)
br label %288
288: ; preds = %286, %279
%289 = bitcast i32* %37 to i8*
%290 = load i32, i32* @CL_MEM_READ_WRITE
%291 = call i32 @clCreateBuffer(i32 %85, i32 %290, i32 %207, i32* null, i64* %19)
store i32 %291, i32* %37
%292 = load i64, i64* %19
%293 = load i64, i64* @CL_SUCCESS
%294 = icmp eq i64 %292, %293
br i1 %294, label %297, label %295
295: ; preds = %288
%296 = call i32 @fatal_CL(i64 %292, i32 409)
br label %297
297: ; preds = %295, %288
%298 = bitcast i32* %38 to i8*
%299 = load i32, i32* @CL_MEM_READ_WRITE
%300 = call i32 @clCreateBuffer(i32 %85, i32 %299, i32 %207, i32* null, i64* %19)
store i32 %300, i32* %38
%301 = load i64, i64* %19
%302 = load i64, i64* @CL_SUCCESS
%303 = icmp eq i64 %301, %302
br i1 %303, label %306, label %304
304: ; preds = %297
%305 = call i32 @fatal_CL(i64 %301, i32 422)
br label %306
306: ; preds = %304, %297
%307 = bitcast i32* %39 to i8*
%308 = load i32, i32* @CL_MEM_READ_WRITE
%309 = call i32 @clCreateBuffer(i32 %85, i32 %308, i32 %207, i32* null, i64* %19)
store i32 %309, i32* %39
%310 = load i64, i64* %19
%311 = load i64, i64* @CL_SUCCESS
%312 = icmp eq i64 %310, %311
br i1 %312, label %315, label %313
313: ; preds = %306
%314 = call i32 @fatal_CL(i64 %310, i32 431)
br label %315
315: ; preds = %313, %306
%316 = load i32, i32* %28
%317 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %122, i32 %316, i32 1, i32 0, i32 %207, float* %0, i32 0, i32 0, i32 0)
store i64 %317, i64* %19
%318 = load i64, i64* @CL_SUCCESS
%319 = icmp eq i64 %317, %318
br i1 %319, label %322, label %320
320: ; preds = %315
%321 = call i32 @fatal_CL(i64 %317, i32 455)
br label %322
322: ; preds = %320, %315
%323 = load i32, i32* %29
%324 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %122, i32 %323, i32 1, i32 0, i32 %12, i32* %7, i32 0, i32 0, i32 0)
store i64 %324, i64* %19
%325 = load i64, i64* @CL_SUCCESS
%326 = icmp eq i64 %324, %325
br i1 %326, label %329, label %327
327: ; preds = %322
%328 = call i32 @fatal_CL(i64 %324, i32 471)
br label %329
329: ; preds = %327, %322
%330 = load i32, i32* %30
%331 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %122, i32 %330, i32 1, i32 0, i32 %12, i32* %8, i32 0, i32 0, i32 0)
store i64 %331, i64* %19
%332 = load i64, i64* @CL_SUCCESS
%333 = icmp eq i64 %331, %332
br i1 %333, label %336, label %334
334: ; preds = %329
%335 = call i32 @fatal_CL(i64 %331, i32 483)
br label %336
336: ; preds = %334, %329
%337 = load i32, i32* %31
%338 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %122, i32 %337, i32 1, i32 0, i32 %13, i32* %9, i32 0, i32 0, i32 0)
store i64 %338, i64* %19
%339 = load i64, i64* @CL_SUCCESS
%340 = icmp eq i64 %338, %339
br i1 %340, label %343, label %341
341: ; preds = %336
%342 = call i32 @fatal_CL(i64 %338, i32 495)
br label %343
343: ; preds = %341, %336
%344 = load i32, i32* %32
%345 = call i64 (i32, i32, i32, i32, i32, ...) @clEnqueueWriteBuffer(i32 %122, i32 %344, i32 1, i32 0, i32 %13, i32* %10, i32 0, i32 0, i32 0)
store i64 %345, i64* %19
%346 = load i64, i64* @CL_SUCCESS
%347 = icmp eq i64 %345, %346
br i1 %347, label %350, label %348
348: ; preds = %343
%349 = call i32 @fatal_CL(i64 %345, i32 507)
br label %350
350: ; preds = %348, %343
%351 = bitcast [1 x i64]* %40 to i8*
%352 = getelementptr inbounds [1 x i64], [1 x i64]* %40, i64 0, i64 0
store i64 128, i64* %352
%353 = bitcast [1 x i64]* %41 to i8*
%354 = load i64, i64* %17
%355 = sdiv i64 %354, 128
%356 = trunc i64 %355 to i32
%357 = and i64 %354, 127
%358 = icmp ne i64 %357, 0
%359 = zext i1 %358 to i32
%360 = add nsw i32 %359, %356
%361 = sext i32 %360 to i64
%362 = shl nsw i64 %361, 7
%363 = getelementptr inbounds [1 x i64], [1 x i64]* %41, i64 0, i64 0
store i64 %362, i64* %363
%364 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @.str.15, i64 0, i64 0), i32 %360, i32 128)
%365 = bitcast i64* %17 to i8*
%366 = call i64 @clSetKernelArg(i32 %163, i32 0, i32 8, i8* %365)
store i64 %366, i64* %19
%367 = load i64, i64* @CL_SUCCESS
%368 = icmp eq i64 %366, %367
br i1 %368, label %371, label %369
369: ; preds = %350
%370 = call i32 @fatal_CL(i64 %366, i32 546)
br label %371
371: ; preds = %369, %350
%372 = call i64 @clSetKernelArg(i32 %163, i32 1, i32 4, i8* %208)
store i64 %372, i64* %19
%373 = load i64, i64* @CL_SUCCESS
%374 = icmp eq i64 %372, %373
br i1 %374, label %377, label %375
375: ; preds = %371
%376 = call i32 @fatal_CL(i64 %372, i32 552)
br label %377
377: ; preds = %375, %371
%378 = call i64 @clEnqueueNDRangeKernel(i32 %122, i32 %163, i32 1, i32* null, i64* %363, i64* %352, i32 0, i32* null, i32* null)
store i64 %378, i64* %19
%379 = load i64, i64* @CL_SUCCESS
%380 = icmp eq i64 %378, %379
br i1 %380, label %383, label %381
381: ; preds = %377
%382 = call i32 @fatal_CL(i64 %378, i32 568)
br label %383
383: ; preds = %381, %377
%384 = call i64 @clSetKernelArg(i32 %170, i32 0, i32 8, i8* %365)
store i64 %384, i64* %19
%385 = load i64, i64* @CL_SUCCESS
%386 = icmp eq i64 %384, %385
br i1 %386, label %389, label %387
387: ; preds = %383
%388 = call i32 @fatal_CL(i64 %384, i32 595)
br label %389
389: ; preds = %387, %383
%390 = call i64 @clSetKernelArg(i32 %170, i32 1, i32 4, i8* %208)
store i64 %390, i64* %19
%391 = load i64, i64* @CL_SUCCESS
%392 = icmp eq i64 %390, %391
br i1 %392, label %395, label %393
393: ; preds = %389
%394 = call i32 @fatal_CL(i64 %390, i32 601)
br label %395
395: ; preds = %393, %389
%396 = call i64 @clSetKernelArg(i32 %170, i32 2, i32 4, i8* %298)
store i64 %396, i64* %19
%397 = load i64, i64* @CL_SUCCESS
%398 = icmp eq i64 %396, %397
br i1 %398, label %401, label %399
399: ; preds = %395
%400 = call i32 @fatal_CL(i64 %396, i32 607)
br label %401
401: ; preds = %399, %395
%402 = call i64 @clSetKernelArg(i32 %170, i32 3, i32 4, i8* %307)
store i64 %402, i64* %19
%403 = load i64, i64* @CL_SUCCESS
%404 = icmp eq i64 %402, %403
br i1 %404, label %407, label %405
405: ; preds = %401
%406 = call i32 @fatal_CL(i64 %402, i32 613)
br label %407
407: ; preds = %405, %401
%408 = bitcast i32* %42 to i8*
%409 = bitcast [1 x i64]* %43 to i8*
%410 = bitcast i64* %44 to i8*
%411 = bitcast i32* %45 to i8*
%412 = bitcast float* %46 to i8*
%413 = bitcast float* %47 to i8*
%414 = bitcast float* %48 to i8*
%415 = call i64 @clSetKernelArg(i32 %177, i32 0, i32 8, i8* %365)
store i64 %415, i64* %19
%416 = load i64, i64* @CL_SUCCESS
%417 = icmp eq i64 %415, %416
br i1 %417, label %420, label %418
418: ; preds = %407
%419 = call i32 @fatal_CL(i64 %415, i32 637)
br label %420
420: ; preds = %418, %407
%421 = call i64 @clSetKernelArg(i32 %177, i32 3, i32 4, i8* %298)
store i64 %421, i64* %19
%422 = load i64, i64* @CL_SUCCESS
%423 = icmp eq i64 %421, %422
br i1 %423, label %426, label %424
424: ; preds = %420
%425 = call i32 @fatal_CL(i64 %421, i32 643)
br label %426
426: ; preds = %424, %420
%427 = call i64 @clSetKernelArg(i32 %177, i32 4, i32 4, i8* %307)
store i64 %427, i64* %19
%428 = load i64, i64* @CL_SUCCESS
%429 = icmp eq i64 %427, %428
br i1 %429, label %432, label %430
430: ; preds = %426
%431 = call i32 @fatal_CL(i64 %427, i32 649)
br label %432
432: ; preds = %430, %426
%433 = bitcast float* %18 to i8*
%434 = call i64 @clSetKernelArg(i32 %184, i32 0, i32 4, i8* %433)
store i64 %434, i64* %19
%435 = load i64, i64* @CL_SUCCESS
%436 = icmp eq i64 %434, %435
br i1 %436, label %439, label %437
437: ; preds = %432
%438 = call i32 @fatal_CL(i64 %434, i32 660)
br label %439
439: ; preds = %437, %432
%440 = bitcast i32* %15 to i8*
%441 = call i64 @clSetKernelArg(i32 %184, i32 1, i32 4, i8* %440)
store i64 %441, i64* %19
%442 = load i64, i64* @CL_SUCCESS
%443 = icmp eq i64 %441, %442
br i1 %443, label %446, label %444
444: ; preds = %439
%445 = call i32 @fatal_CL(i64 %441, i32 666)
br label %446
446: ; preds = %444, %439
%447 = bitcast i32* %16 to i8*
%448 = call i64 @clSetKernelArg(i32 %184, i32 2, i32 4, i8* %447)
store i64 %448, i64* %19
%449 = load i64, i64* @CL_SUCCESS
%450 = icmp eq i64 %448, %449
br i1 %450, label %453, label %451
451: ; preds = %446
%452 = call i32 @fatal_CL(i64 %448, i32 672)
br label %453
453: ; preds = %451, %446
%454 = call i64 @clSetKernelArg(i32 %184, i32 3, i32 8, i8* %365)
store i64 %454, i64* %19
%455 = load i64, i64* @CL_SUCCESS
%456 = icmp eq i64 %454, %455
br i1 %456, label %459, label %457
457: ; preds = %453
%458 = call i32 @fatal_CL(i64 %454, i32 678)
br label %459
459: ; preds = %457, %453
%460 = call i64 @clSetKernelArg(i32 %184, i32 4, i32 4, i8* %217)
store i64 %460, i64* %19
%461 = load i64, i64* @CL_SUCCESS
%462 = icmp eq i64 %460, %461
br i1 %462, label %465, label %463
463: ; preds = %459
%464 = call i32 @fatal_CL(i64 %460, i32 684)
br label %465
465: ; preds = %463, %459
%466 = call i64 @clSetKernelArg(i32 %184, i32 5, i32 4, i8* %226)
store i64 %466, i64* %19
%467 = load i64, i64* @CL_SUCCESS
%468 = icmp eq i64 %466, %467
br i1 %468, label %471, label %469
469: ; preds = %465
%470 = call i32 @fatal_CL(i64 %466, i32 690)
br label %471
471: ; preds = %469, %465
%472 = call i64 @clSetKernelArg(i32 %184, i32 6, i32 4, i8* %235)
store i64 %472, i64* %19
%473 = load i64, i64* @CL_SUCCESS
%474 = icmp eq i64 %472, %473
br i1 %474, label %477, label %475
475: ; preds = %471
%476 = call i32 @fatal_CL(i64 %472, i32 696)
br label %477
477: ; preds = %475, %471
%478 = call i64 @clSetKernelArg(i32 %184, i32 7, i32 4, i8* %244)
store i64 %478, i64* %19
%479 = load i64, i64* @CL_SUCCESS
%480 = icmp eq i64 %478, %479
br i1 %480, label %483, label %481
481: ; preds = %477
%482 = call i32 @fatal_CL(i64 %478, i32 702)
br label %483
483: ; preds = %481, %477
%484 = call i64 @clSetKernelArg(i32 %184, i32 8, i32 4, i8* %253)
store i64 %484, i64* %19
%485 = load i64, i64* @CL_SUCCESS
%486 = icmp eq i64 %484, %485
br i1 %486, label %489, label %487
487: ; preds = %483
%488 = call i32 @fatal_CL(i64 %484, i32 708)
br label %489
489: ; preds = %487, %483
%490 = call i64 @clSetKernelArg(i32 %184, i32 9, i32 4, i8* %262)
store i64 %490, i64* %19
%491 = load i64, i64* @CL_SUCCESS
%492 = icmp eq i64 %490, %491
br i1 %492, label %495, label %493
493: ; preds = %489
%494 = call i32 @fatal_CL(i64 %490, i32 714)
br label %495
495: ; preds = %493, %489
%496 = call i64 @clSetKernelArg(i32 %184, i32 10, i32 4, i8* %271)
store i64 %496, i64* %19
%497 = load i64, i64* @CL_SUCCESS
%498 = icmp eq i64 %496, %497
br i1 %498, label %501, label %499
499: ; preds = %495
%500 = call i32 @fatal_CL(i64 %496, i32 720)
br label %501
501: ; preds = %499, %495
%502 = call i64 @clSetKernelArg(i32 %184, i32 11, i32 4, i8* %280)
store i64 %502, i64* %19
%503 = load i64, i64* @CL_SUCCESS
%504 = icmp eq i64 %502, %503
br i1 %504, label %507, label %505
505: ; preds = %501
%506 = call i32 @fatal_CL(i64 %502, i32 726)
br label %507
507: ; preds = %505, %501
%508 = call i64 @clSetKernelArg(i32 %184, i32 13, i32 4, i8* %289)
store i64 %508, i64* %19
%509 = load i64, i64* @CL_SUCCESS
%510 = icmp eq i64 %508, %509
br i1 %510, label %513, label %511
511: ; preds = %507
%512 = call i32 @fatal_CL(i64 %508, i32 732)
br label %513
513: ; preds = %511, %507
%514 = call i64 @clSetKernelArg(i32 %184, i32 14, i32 4, i8* %208)
store i64 %514, i64* %19
%515 = load i64, i64* @CL_SUCCESS
%516 = icmp eq i64 %514, %515
br i1 %516, label %519, label %517
517: ; preds = %513
%518 = call i32 @fatal_CL(i64 %514, i32 738)
br label %519
519: ; preds = %517, %513
%520 = call i64 @clSetKernelArg(i32 %191, i32 0, i32 4, i8* %433)
store i64 %520, i64* %19
%521 = load i64, i64* @CL_SUCCESS
%522 = icmp eq i64 %520, %521
br i1 %522, label %525, label %523
523: ; preds = %519
%524 = call i32 @fatal_CL(i64 %520, i32 749)
br label %525
525: ; preds = %523, %519
%526 = call i64 @clSetKernelArg(i32 %191, i32 1, i32 4, i8* %440)
store i64 %526, i64* %19
%527 = load i64, i64* @CL_SUCCESS
%528 = icmp eq i64 %526, %527
br i1 %528, label %531, label %529
529: ; preds = %525
%530 = call i32 @fatal_CL(i64 %526, i32 755)
br label %531
531: ; preds = %529, %525
%532 = call i64 @clSetKernelArg(i32 %191, i32 2, i32 4, i8* %447)
store i64 %532, i64* %19
%533 = load i64, i64* @CL_SUCCESS
%534 = icmp eq i64 %532, %533
br i1 %534, label %537, label %535
535: ; preds = %531
%536 = call i32 @fatal_CL(i64 %532, i32 761)
br label %537
537: ; preds = %535, %531
%538 = call i64 @clSetKernelArg(i32 %191, i32 3, i32 8, i8* %365)
store i64 %538, i64* %19
%539 = load i64, i64* @CL_SUCCESS
%540 = icmp eq i64 %538, %539
br i1 %540, label %543, label %541
541: ; preds = %537
%542 = call i32 @fatal_CL(i64 %538, i32 767)
br label %543
543: ; preds = %541, %537
%544 = call i64 @clSetKernelArg(i32 %191, i32 4, i32 4, i8* %217)
store i64 %544, i64* %19
%545 = load i64, i64* @CL_SUCCESS
%546 = icmp eq i64 %544, %545
br i1 %546, label %549, label %547
547: ; preds = %543
%548 = call i32 @fatal_CL(i64 %544, i32 773)
br label %549
549: ; preds = %547, %543
%550 = call i64 @clSetKernelArg(i32 %191, i32 5, i32 4, i8* %226)
store i64 %550, i64* %19
%551 = load i64, i64* @CL_SUCCESS
%552 = icmp eq i64 %550, %551
br i1 %552, label %555, label %553
553: ; preds = %549
%554 = call i32 @fatal_CL(i64 %550, i32 779)
br label %555
555: ; preds = %553, %549
%556 = call i64 @clSetKernelArg(i32 %191, i32 6, i32 4, i8* %235)
store i64 %556, i64* %19
%557 = load i64, i64* @CL_SUCCESS
%558 = icmp eq i64 %556, %557
br i1 %558, label %561, label %559
559: ; preds = %555
%560 = call i32 @fatal_CL(i64 %556, i32 785)
br label %561
561: ; preds = %559, %555
%562 = call i64 @clSetKernelArg(i32 %191, i32 7, i32 4, i8* %244)
store i64 %562, i64* %19
%563 = load i64, i64* @CL_SUCCESS
%564 = icmp eq i64 %562, %563
br i1 %564, label %567, label %565
565: ; preds = %561
%566 = call i32 @fatal_CL(i64 %562, i32 791)
br label %567
567: ; preds = %565, %561
%568 = call i64 @clSetKernelArg(i32 %191, i32 8, i32 4, i8* %253)
store i64 %568, i64* %19
%569 = load i64, i64* @CL_SUCCESS
%570 = icmp eq i64 %568, %569
br i1 %570, label %573, label %571
571: ; preds = %567
%572 = call i32 @fatal_CL(i64 %568, i32 797)
br label %573
573: ; preds = %571, %567
%574 = call i64 @clSetKernelArg(i32 %191, i32 9, i32 4, i8* %262)
store i64 %574, i64* %19
%575 = load i64, i64* @CL_SUCCESS
%576 = icmp eq i64 %574, %575
br i1 %576, label %579, label %577
577: ; preds = %573
%578 = call i32 @fatal_CL(i64 %574, i32 803)
br label %579
579: ; preds = %577, %573
%580 = call i64 @clSetKernelArg(i32 %191, i32 10, i32 4, i8* %271)
store i64 %580, i64* %19
%581 = load i64, i64* @CL_SUCCESS
%582 = icmp eq i64 %580, %581
br i1 %582, label %585, label %583
583: ; preds = %579
%584 = call i32 @fatal_CL(i64 %580, i32 809)
br label %585
585: ; preds = %583, %579
%586 = call i64 @clSetKernelArg(i32 %191, i32 11, i32 4, i8* %280)
store i64 %586, i64* %19
%587 = load i64, i64* @CL_SUCCESS
%588 = icmp eq i64 %586, %587
br i1 %588, label %591, label %589
589: ; preds = %585
%590 = call i32 @fatal_CL(i64 %586, i32 815)
br label %591
591: ; preds = %589, %585
%592 = call i64 @clSetKernelArg(i32 %191, i32 12, i32 4, i8* %289)
store i64 %592, i64* %19
%593 = load i64, i64* @CL_SUCCESS
%594 = icmp eq i64 %592, %593
br i1 %594, label %597, label %595
595: ; preds = %591
%596 = call i32 @fatal_CL(i64 %592, i32 821)
br label %597
597: ; preds = %595, %591
%598 = call i64 @clSetKernelArg(i32 %191, i32 13, i32 4, i8* %208)
store i64 %598, i64* %19
%599 = load i64, i64* @CL_SUCCESS
%600 = icmp eq i64 %598, %599
br i1 %600, label %603, label %601
601: ; preds = %597
%602 = call i32 @fatal_CL(i64 %598, i32 827)
br label %603
603: ; preds = %601, %597
%604 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.16, i64 0, i64 0))
%605 = icmp sgt i32 %4, 0
br i1 %605, label %606, label %708
606: ; preds = %603
%607 = getelementptr inbounds [1 x i64], [1 x i64]* %43, i64 0, i64 0
%608 = sitofp i64 %6 to float
%609 = icmp eq i32 %360, 0
br label %610
610: ; preds = %606, %705
%611 = phi i32 [ 0, %606 ], [ %706, %705 ]
%612 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i64 0, i64 0), i32 %611)
%613 = call i32 @fflush(i32* null)
%614 = call i64 @clEnqueueNDRangeKernel(i32 %122, i32 %170, i32 1, i32* null, i64* %363, i64* %352, i32 0, i32* null, i32* null)
store i64 %614, i64* %19
%615 = load i64, i64* @CL_SUCCESS
%616 = icmp eq i64 %614, %615
br i1 %616, label %619, label %617
617: ; preds = %610
%618 = call i32 @fatal_CL(i64 %614, i32 860)
br label %619
619: ; preds = %617, %610
store i32 %360, i32* %42
%620 = load i64, i64* %363
store i64 %620, i64* %607
%621 = load i64, i64* %17
store i64 %621, i64* %44
store i32 1, i32* %45
br i1 %609, label %664, label %622
622: ; preds = %619, %651
%623 = call i64 @clSetKernelArg(i32 %177, i32 1, i32 8, i8* %410)
store i64 %623, i64* %19
%624 = load i64, i64* @CL_SUCCESS
%625 = icmp eq i64 %623, %624
br i1 %625, label %628, label %626
626: ; preds = %622
%627 = call i32 @fatal_CL(i64 %623, i32 886)
br label %628
628: ; preds = %626, %622
%629 = call i64 @clSetKernelArg(i32 %177, i32 2, i32 4, i8* %411)
store i64 %629, i64* %19
%630 = load i64, i64* @CL_SUCCESS
%631 = icmp eq i64 %629, %630
br i1 %631, label %634, label %632
632: ; preds = %628
%633 = call i32 @fatal_CL(i64 %629, i32 892)
br label %634
634: ; preds = %632, %628
%635 = call i64 @clSetKernelArg(i32 %177, i32 5, i32 4, i8* %408)
store i64 %635, i64* %19
%636 = load i64, i64* @CL_SUCCESS
%637 = icmp eq i64 %635, %636
br i1 %637, label %640, label %638
638: ; preds = %634
%639 = call i32 @fatal_CL(i64 %635, i32 899)
br label %640
640: ; preds = %638, %634
%641 = call i64 @clEnqueueNDRangeKernel(i32 %122, i32 %177, i32 1, i32* null, i64* %607, i64* %352, i32 0, i32* null, i32* null)
store i64 %641, i64* %19
%642 = load i64, i64* @CL_SUCCESS
%643 = icmp eq i64 %641, %642
br i1 %643, label %646, label %644
644: ; preds = %640
%645 = call i32 @fatal_CL(i64 %641, i32 912)
br label %646
646: ; preds = %644, %640
%647 = load i32, i32* %42
%648 = sext i32 %647 to i64
store i64 %648, i64* %44
%649 = icmp eq i32 %647, 1
br i1 %649, label %650, label %651
650: ; preds = %646
store i32 0, i32* %42
br label %664
651: ; preds = %646
%652 = load i32, i32* %45
%653 = shl nsw i32 %652, 7
store i32 %653, i32* %45
%654 = load i64, i64* %352
%655 = trunc i64 %654 to i32
%656 = sdiv i32 %647, %655
%657 = srem i32 %647, %655
%658 = icmp ne i32 %657, 0
%659 = zext i1 %658 to i32
%660 = add nsw i32 %656, %659
store i32 %660, i32* %42
%661 = mul nsw i32 %660, %655
%662 = sext i32 %661 to i64
store i64 %662, i64* %607
%663 = icmp eq i32 %660, 0
br i1 %663, label %664, label %622
664: ; preds = %651, %650, %619
%665 = load i32, i32* %38
%666 = load i32, i32* @CL_TRUE
%667 = call i64 @clEnqueueReadBuffer(i32 %122, i32 %665, i32 %666, i32 0, i32 4, float* %46, i32 0, i32* null, i32* null)
store i64 %667, i64* %19
%668 = load i64, i64* @CL_SUCCESS
%669 = icmp eq i64 %667, %668
br i1 %669, label %672, label %670
670: ; preds = %664
%671 = call i32 @fatal_CL(i64 %667, i32 947)
br label %672
672: ; preds = %670, %664
%673 = load i32, i32* %39
%674 = load i32, i32* @CL_TRUE
%675 = call i64 @clEnqueueReadBuffer(i32 %122, i32 %673, i32 %674, i32 0, i32 4, float* %47, i32 0, i32* null, i32* null)
store i64 %675, i64* %19
%676 = load i64, i64* @CL_SUCCESS
%677 = icmp eq i64 %675, %676
br i1 %677, label %680, label %678
678: ; preds = %672
%679 = call i32 @fatal_CL(i64 %675, i32 959)
br label %680
680: ; preds = %678, %672
%681 = load float, float* %46
%682 = fdiv float %681, %608
%683 = fmul float %682, %682
%684 = load float, float* %47
%685 = fdiv float %684, %608
%686 = fsub float %685, %683
%687 = fdiv float %686, %683
store float %687, float* %48
%688 = call i64 @clSetKernelArg(i32 %184, i32 12, i32 4, i8* %414)
store i64 %688, i64* %19
%689 = load i64, i64* @CL_SUCCESS
%690 = icmp eq i64 %688, %689
br i1 %690, label %693, label %691
691: ; preds = %680
%692 = call i32 @fatal_CL(i64 %688, i32 980)
br label %693
693: ; preds = %691, %680
%694 = call i64 @clEnqueueNDRangeKernel(i32 %122, i32 %184, i32 1, i32* null, i64* %363, i64* %352, i32 0, i32* null, i32* null)
store i64 %694, i64* %19
%695 = load i64, i64* @CL_SUCCESS
%696 = icmp eq i64 %694, %695
br i1 %696, label %699, label %697
697: ; preds = %693
%698 = call i32 @fatal_CL(i64 %694, i32 993)
br label %699
699: ; preds = %697, %693
%700 = call i64 @clEnqueueNDRangeKernel(i32 %122, i32 %191, i32 1, i32* null, i64* %363, i64* %352, i32 0, i32* null, i32* null)
store i64 %700, i64* %19
%701 = load i64, i64* @CL_SUCCESS
%702 = icmp eq i64 %700, %701
br i1 %702, label %705, label %703
703: ; preds = %699
%704 = call i32 @fatal_CL(i64 %700, i32 1015)
br label %705
705: ; preds = %699, %703
%706 = add nuw nsw i32 %611, 1
%707 = icmp eq i32 %706, %4
br i1 %707, label %708, label %610
708: ; preds = %705, %603
%709 = call i32 @putchar(i32 10)
%710 = call i64 @clSetKernelArg(i32 %198, i32 0, i32 8, i8* %365)
store i64 %710, i64* %19
%711 = load i64, i64* @CL_SUCCESS
%712 = icmp eq i64 %710, %711
br i1 %712, label %715, label %713
713: ; preds = %708
%714 = call i32 @fatal_CL(i64 %710, i32 1043)
br label %715
715: ; preds = %713, %708
%716 = call i64 @clSetKernelArg(i32 %198, i32 1, i32 4, i8* %208)
store i64 %716, i64* %19
%717 = load i64, i64* @CL_SUCCESS
%718 = icmp eq i64 %716, %717
br i1 %718, label %721, label %719
719: ; preds = %715
%720 = call i32 @fatal_CL(i64 %716, i32 1049)
br label %721
721: ; preds = %719, %715
%722 = call i64 @clEnqueueNDRangeKernel(i32 %122, i32 %198, i32 1, i32* null, i64* %363, i64* %352, i32 0, i32* null, i32* null)
store i64 %722, i64* %19
%723 = load i64, i64* @CL_SUCCESS
%724 = icmp eq i64 %722, %723
br i1 %724, label %727, label %725
725: ; preds = %721
%726 = call i32 @fatal_CL(i64 %722, i32 1065)
br label %727
727: ; preds = %725, %721
%728 = call i64 @clFinish(i32 %122)
store i64 %728, i64* %19
%729 = load i64, i64* @CL_SUCCESS
%730 = icmp eq i64 %728, %729
br i1 %730, label %733, label %731
731: ; preds = %727
%732 = call i32 @fatal_CL(i64 %728, i32 1073)
br label %733
733: ; preds = %731, %727
%734 = load i32, i32* %28
%735 = load i32, i32* @CL_TRUE
%736 = call i64 @clEnqueueReadBuffer(i32 %122, i32 %734, i32 %735, i32 0, i32 %207, float* %0, i32 0, i32* null, i32* null)
store i64 %736, i64* %19
%737 = load i64, i64* @CL_SUCCESS
%738 = icmp eq i64 %736, %737
br i1 %738, label %741, label %739
739: ; preds = %733
%740 = call i32 @fatal_CL(i64 %736, i32 1093)
br label %741
741: ; preds = %739, %733
%742 = call i64 @clReleaseKernel(i32 %163)
store i64 %742, i64* %19
%743 = load i64, i64* @CL_SUCCESS
%744 = icmp eq i64 %742, %743
br i1 %744, label %747, label %745
745: ; preds = %741
%746 = call i32 @fatal_CL(i64 %742, i32 1107)
br label %747
747: ; preds = %745, %741
%748 = call i64 @clReleaseKernel(i32 %170)
store i64 %748, i64* %19
%749 = load i64, i64* @CL_SUCCESS
%750 = icmp eq i64 %748, %749
br i1 %750, label %753, label %751
751: ; preds = %747
%752 = call i32 @fatal_CL(i64 %748, i32 1110)
br label %753
753: ; preds = %751, %747
%754 = call i64 @clReleaseKernel(i32 %177)
store i64 %754, i64* %19
%755 = load i64, i64* @CL_SUCCESS
%756 = icmp eq i64 %754, %755
br i1 %756, label %759, label %757
757: ; preds = %753
%758 = call i32 @fatal_CL(i64 %754, i32 1113)
br label %759
759: ; preds = %757, %753
%760 = call i64 @clReleaseKernel(i32 %184)
store i64 %760, i64* %19
%761 = load i64, i64* @CL_SUCCESS
%762 = icmp eq i64 %760, %761
br i1 %762, label %765, label %763
763: ; preds = %759
%764 = call i32 @fatal_CL(i64 %760, i32 1116)
br label %765
765: ; preds = %763, %759
%766 = call i64 @clReleaseKernel(i32 %191)
store i64 %766, i64* %19
%767 = load i64, i64* @CL_SUCCESS
%768 = icmp eq i64 %766, %767
br i1 %768, label %771, label %769
769: ; preds = %765
%770 = call i32 @fatal_CL(i64 %766, i32 1119)
br label %771
771: ; preds = %769, %765
%772 = call i64 @clReleaseKernel(i32 %198)
store i64 %772, i64* %19
%773 = load i64, i64* @CL_SUCCESS
%774 = icmp eq i64 %772, %773
br i1 %774, label %777, label %775
775: ; preds = %771
%776 = call i32 @fatal_CL(i64 %772, i32 1122)
br label %777
777: ; preds = %775, %771
%778 = call i64 @clReleaseProgram(i32 %133)
store i64 %778, i64* %19
%779 = load i64, i64* @CL_SUCCESS
%780 = icmp eq i64 %778, %779
br i1 %780, label %783, label %781
781: ; preds = %777
%782 = call i32 @fatal_CL(i64 %778, i32 1125)
br label %783
783: ; preds = %781, %777
%784 = load i32, i32* %28
%785 = call i64 @clReleaseMemObject(i32 %784)
store i64 %785, i64* %19
%786 = load i64, i64* @CL_SUCCESS
%787 = icmp eq i64 %785, %786
br i1 %787, label %790, label %788
788: ; preds = %783
%789 = call i32 @fatal_CL(i64 %785, i32 1130)
br label %790
790: ; preds = %788, %783
%791 = load i32, i32* %37
%792 = call i64 @clReleaseMemObject(i32 %791)
store i64 %792, i64* %19
%793 = load i64, i64* @CL_SUCCESS
%794 = icmp eq i64 %792, %793
br i1 %794, label %797, label %795
795: ; preds = %790
%796 = call i32 @fatal_CL(i64 %792, i32 1133)
br label %797
797: ; preds = %795, %790
%798 = load i32, i32* %29
%799 = call i64 @clReleaseMemObject(i32 %798)
store i64 %799, i64* %19
%800 = load i64, i64* @CL_SUCCESS
%801 = icmp eq i64 %799, %800
br i1 %801, label %804, label %802
802: ; preds = %797
%803 = call i32 @fatal_CL(i64 %799, i32 1137)
br label %804
804: ; preds = %802, %797
%805 = load i32, i32* %30
%806 = call i64 @clReleaseMemObject(i32 %805)
store i64 %806, i64* %19
%807 = load i64, i64* @CL_SUCCESS
%808 = icmp eq i64 %806, %807
br i1 %808, label %811, label %809
809: ; preds = %804
%810 = call i32 @fatal_CL(i64 %806, i32 1140)
br label %811
811: ; preds = %809, %804
%812 = load i32, i32* %31
%813 = call i64 @clReleaseMemObject(i32 %812)
store i64 %813, i64* %19
%814 = load i64, i64* @CL_SUCCESS
%815 = icmp eq i64 %813, %814
br i1 %815, label %818, label %816
816: ; preds = %811
%817 = call i32 @fatal_CL(i64 %813, i32 1143)
br label %818
818: ; preds = %816, %811
%819 = load i32, i32* %32
%820 = call i64 @clReleaseMemObject(i32 %819)
store i64 %820, i64* %19
%821 = load i64, i64* @CL_SUCCESS
%822 = icmp eq i64 %820, %821
br i1 %822, label %825, label %823
823: ; preds = %818
%824 = call i32 @fatal_CL(i64 %820, i32 1146)
br label %825
825: ; preds = %823, %818
%826 = load i32, i32* %33
%827 = call i64 @clReleaseMemObject(i32 %826)
store i64 %827, i64* %19
%828 = load i64, i64* @CL_SUCCESS
%829 = icmp eq i64 %827, %828
br i1 %829, label %832, label %830
830: ; preds = %825
%831 = call i32 @fatal_CL(i64 %827, i32 1150)
br label %832
832: ; preds = %830, %825
%833 = load i32, i32* %34
%834 = call i64 @clReleaseMemObject(i32 %833)
store i64 %834, i64* %19
%835 = load i64, i64* @CL_SUCCESS
%836 = icmp eq i64 %834, %835
br i1 %836, label %839, label %837
837: ; preds = %832
%838 = call i32 @fatal_CL(i64 %834, i32 1153)
br label %839
839: ; preds = %837, %832
%840 = load i32, i32* %36
%841 = call i64 @clReleaseMemObject(i32 %840)
store i64 %841, i64* %19
%842 = load i64, i64* @CL_SUCCESS
%843 = icmp eq i64 %841, %842
br i1 %843, label %846, label %844
844: ; preds = %839
%845 = call i32 @fatal_CL(i64 %841, i32 1156)
br label %846
846: ; preds = %844, %839
%847 = load i32, i32* %35
%848 = call i64 @clReleaseMemObject(i32 %847)
store i64 %848, i64* %19
%849 = load i64, i64* @CL_SUCCESS
%850 = icmp eq i64 %848, %849
br i1 %850, label %853, label %851
851: ; preds = %846
%852 = call i32 @fatal_CL(i64 %848, i32 1159)
br label %853
853: ; preds = %851, %846
%854 = load i32, i32* %38
%855 = call i64 @clReleaseMemObject(i32 %854)
store i64 %855, i64* %19
%856 = load i64, i64* @CL_SUCCESS
%857 = icmp eq i64 %855, %856
br i1 %857, label %860, label %858
858: ; preds = %853
%859 = call i32 @fatal_CL(i64 %855, i32 1163)
br label %860
860: ; preds = %858, %853
%861 = load i32, i32* %39
%862 = call i64 @clReleaseMemObject(i32 %861)
store i64 %862, i64* %19
%863 = load i64, i64* @CL_SUCCESS
%864 = icmp eq i64 %862, %863
br i1 %864, label %867, label %865
865: ; preds = %860
%866 = call i32 @fatal_CL(i64 %862, i32 1166)
br label %867
867: ; preds = %865, %860
%868 = call i64 @clFlush(i32 %122)
store i64 %868, i64* %19
%869 = load i64, i64* @CL_SUCCESS
%870 = icmp eq i64 %868, %869
br i1 %870, label %873, label %871
871: ; preds = %867
%872 = call i32 @fatal_CL(i64 %868, i32 1171)
br label %873
873: ; preds = %871, %867
%874 = call i64 @clReleaseCommandQueue(i32 %122)
store i64 %874, i64* %19
%875 = load i64, i64* @CL_SUCCESS
%876 = icmp eq i64 %874, %875
br i1 %876, label %879, label %877
877: ; preds = %873
%878 = call i32 @fatal_CL(i64 %874, i32 1174)
br label %879
879: ; preds = %877, %873
%880 = call i64 @clReleaseContext(i32 %85)
store i64 %880, i64* %19
%881 = load i64, i64* @CL_SUCCESS
%882 = icmp eq i64 %880, %881
br i1 %882, label %885, label %883
883: ; preds = %879
%884 = call i32 @fatal_CL(i64 %880, i32 1177)
br label %885
885: ; preds = %883, %879
ret void
}