// (c) Copyright 2013 Lev Barash, Landau Institute for Theoretical Physics, Russian Academy of Sciences
// This is supplement to the paper:
// L.Yu. Barash, L.N. Shchur, "PRAND: GPU accelerated parallel random number generation library: Using most reliable algorithms and applying parallelism of modern GPUs and CPUs".
// e-mail: barash @ itp.ac.ru (remove space)

#include<stdio.h>

#define gq58x4_CUDA_CALL(x) do { if((x) != cudaSuccess) { printf("Error: %s at %s:%d\n",cudaGetErrorString(cudaGetLastError()),__FILE__,__LINE__); exit(1);}} while(0)

#define gq58x4_BLOCKS  128
#define gq58x4_THREADS 128
#define gq58x4_ARRAY_SECTIONS (gq58x4_BLOCKS*gq58x4_THREADS/8)

#define gq58x4_k 8
#define gq58x4_q 48
#define gq58x4_g       288230374541099008ULL
#define gq58x4_gdiv16  18014398408818688ULL

typedef unsigned long long lt;

typedef struct{
  lt xN[8] __attribute__ ((aligned(16))),
     xP[8] __attribute__ ((aligned(16)));
} gq58x4_state;

typedef gq58x4_state gq58x4_sse_state;

lt gq58x4_sse_Consts[8] __attribute__ ((aligned(16))) =
   {13835057977972752384ULL,13835057977972752384ULL,1610612736ULL,1610612736ULL,
    288230371923853311ULL,288230371923853311ULL,288230374541099008ULL,288230374541099008ULL};

__host__ unsigned int gq58x4_sse_generate_(gq58x4_sse_state* state){
  unsigned output;
  asm volatile("movaps (%3),%%xmm0\n" \

      "movaps (%2),%%xmm1\n" \
      "movaps (%1),%%xmm4\n" \
      "movaps %%xmm4,(%2)\n" \
      "psllq  $3,%%xmm4\n" \
      "paddq  %%xmm0,%%xmm4\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm4\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm4\n" \
      "movaps %%xmm4,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm4\n" \
      "paddq  %%xmm3,%%xmm4\n" \
      "movaps %%xmm4,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm4\n" \
      "movaps %%xmm4,(%1)\n" \
      "movaps %%xmm4,%%xmm1\n" \
      "paddq  %%xmm4,%%xmm1\n" \
      "paddq  %%xmm4,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm4\n" \


      "movaps 16(%2),%%xmm1\n" \
      "movaps 16(%1),%%xmm5\n" \
      "movaps %%xmm5,16(%2)\n" \
      "psllq  $3,%%xmm5\n" \
      "paddq  %%xmm0,%%xmm5\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm5\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm5\n" \
      "movaps %%xmm5,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm5\n" \
      "paddq  %%xmm3,%%xmm5\n" \
      "movaps %%xmm5,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm5\n" \
      "movaps %%xmm5,16(%1)\n" \
      "movaps %%xmm5,%%xmm1\n" \
      "paddq  %%xmm5,%%xmm1\n" \
      "paddq  %%xmm5,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm5\n" \

      "movaps 32(%2),%%xmm1\n" \
      "movaps 32(%1),%%xmm6\n" \
      "movaps %%xmm6,32(%2)\n" \
      "psllq  $3,%%xmm6\n" \
      "paddq  %%xmm0,%%xmm6\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm6\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm6\n" \
      "movaps %%xmm6,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm6\n" \
      "paddq  %%xmm3,%%xmm6\n" \
      "movaps %%xmm6,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm6\n" \
      "movaps %%xmm6,32(%1)\n" \
      "movaps %%xmm6,%%xmm1\n" \
      "paddq  %%xmm6,%%xmm1\n" \
      "paddq  %%xmm6,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm6\n" \

      "movaps 48(%2),%%xmm1\n" \
      "movaps 48(%1),%%xmm7\n" \
      "movaps %%xmm7,48(%2)\n" \
      "psllq  $3,%%xmm7\n" \
      "paddq  %%xmm0,%%xmm7\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm7\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm7\n" \
      "movaps %%xmm7,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm7\n" \
      "paddq  %%xmm3,%%xmm7\n" \
      "movaps %%xmm7,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm7\n" \
      "movaps %%xmm7,48(%1)\n" \
      "movaps %%xmm7,%%xmm1\n" \
      "paddq  %%xmm7,%%xmm1\n" \
      "paddq  %%xmm7,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm7\n" \

      "psrlq  $54,%%xmm4\n" \
      "psrlq  $54,%%xmm5\n" \
      "psrlq  $54,%%xmm6\n" \
      "psrlq  $54,%%xmm7\n" \
      "packssdw  %%xmm5,%%xmm4\n" \
      "packssdw  %%xmm7,%%xmm6\n" \
      "packssdw  %%xmm6,%%xmm4\n" \
      "packsswb  %%xmm4,%%xmm4\n" \
      "movaps  %%xmm4,%%xmm0\n" \
      "psrldq   $4,%%xmm0\n" \
      "pslld    $4,%%xmm0\n" \
      "pxor    %%xmm0,%%xmm4\n"
      "movd    %%xmm4,%0\n" \
      "":"=&r"(output):"r"(state->xN),"r"(state->xP),"r"(gq58x4_sse_Consts));
      return output;
}

__device__ __host__ void gq58x4_get_sse_state_(gq58x4_state* state,gq58x4_sse_state* sse_state){
  int i; for(i=0;i<8;i++) {sse_state->xN[i]=state->xN[i]; sse_state->xP[i]=state->xP[i];}
}


__device__ __host__ lt gq58x4_mod_g(lt x){ // returns x (mod g)
  lt F,G; F = (x>>58); G = x-(F<<58)+(F<<29)+(F<<30);
  return ((G>=gq58x4_g) ? (G-gq58x4_g) : G);
}

__device__ __host__ lt gq58x4_MyMult(lt A,lt B){ // returns AB (mod gq58x4_g), where it is implied that A,B<gq58x4_g;
  lt A1,A0,B1,B0,curr,x,m;
  A1=A>>32; B1=B>>32; A0=A-(A1<<32)+(12*A1); B0=B-(B1<<32)+(12*B1);
  if(A0>>32) {A0-=4294967284ULL; A1++;}
  if(B0>>32) {B0-=4294967284ULL; B1++;}
  curr=A1*B0+B1*A0; m=curr>>26; x=curr-(m<<26);
  curr=((3*m+(x<<4))<<28)+(gq58x4_g-12*x)+(144*A1*B1)+(gq58x4_mod_g(A0*B0));
  return gq58x4_mod_g(curr);
}

__device__ __host__ lt gq58x4_CNext2(lt N,lt P,lt myk,lt myq){   // returns (myk*N-myq*P) (mod gq58x4_g)
  lt curr1,curr2;
  curr1=gq58x4_MyMult(myk,N); curr2=gq58x4_MyMult(myq,P);
  if(curr1>=curr2) return (curr1-curr2); else return (gq58x4_g+curr1-curr2);
}

__device__ __host__ lt gq58x4_CNext(lt N,lt P){ // returns (8N-48P) (mod gq58x4_g)
  return gq58x4_mod_g((N+6*(gq58x4_g-P))<<3);
}


__device__ __host__ lt gq58x4_GetNextN(lt x0,lt x1,unsigned int n){ //returns x_{2^n}
  lt myk=gq58x4_k,myq=gq58x4_q,i,x=x1;
  for(i=0;i<n;i++){
    x=gq58x4_CNext2(x,x0,myk,myq);
    myk=gq58x4_CNext2(myk,2,myk,myq);
    myq=gq58x4_CNext2(myq,0,myq,0);
  }
  return x;
}

__device__ __host__ lt gq58x4_GetNextAny(lt x0,lt x1,lt N64,lt N0){ //N=2^64*N64+N0+1
  lt i,xp=x0,xn=x1,xpnew,xnnew,shift=0;
  i=N0; while(i>0){
    if(i%2==1){                        // xp,xn ----> 2^shift
      xpnew=gq58x4_GetNextN(xp,xn,shift);
      xnnew=gq58x4_GetNextN(xn,gq58x4_CNext(xn,xp),shift);
      xp=xpnew; xn=xnnew;
    }
    i/=2; shift++;
  }
  i=N64; shift=64; while(i>0){
    if(i%2==1){                        // xp,xn ----> 2^shift
      xpnew=gq58x4_GetNextN(xp,xn,shift);
      xnnew=gq58x4_GetNextN(xn,gq58x4_CNext(xn,xp),shift);
      xp=xpnew; xn=xnnew;
    }
    i/=2; shift++;
  }
  return xp;                       // returns x_N, where N=2^64*N64+N0+1
}

__device__ __host__ void gq58x4_skipahead_(gq58x4_state* state, lt offset64, lt offset0){ // offset=offset64*2^64+offset0+1
  lt xn,xp,j; 
  for(j=0;j<8;j++){
    xp=gq58x4_GetNextAny(state->xP[j],state->xN[j],offset64,offset0);
    xn=gq58x4_GetNextAny(state->xP[j],state->xN[j],offset64,offset0+1);
    state->xP[j]=xp; state->xN[j]=xn;
  }
}

__device__ __host__ void gq58x4_init_(gq58x4_state* state){
  lt x0=100152853817629549ULL,x1=132388305121829306ULL,xp,xn,j;
  for(j=0;j<8;j++){
    xp=gq58x4_GetNextAny(x0,x1,0,35048736516210783ULL);
    xn=gq58x4_GetNextAny(x0,x1,0,35048736516210784ULL);
    state->xP[j]=xp; state->xN[j]=xn; x0=xp; x1=xn;
  }
}

__device__ __host__ void gq58x4_init_short_sequence_(gq58x4_state* state,unsigned SequenceNumber){
  gq58x4_init_(state);                     // 0 <= SequenceNumber < 3*10^8;   length of each sequence <= 8*10^7
  gq58x4_skipahead_(state,0,82927047ULL*(unsigned long long)SequenceNumber);
}

__device__ __host__ void gq58x4_init_medium_sequence_(gq58x4_state* state,unsigned SequenceNumber){
  gq58x4_init_(state);                     // 0 <= SequenceNumber < 3*10^6;   length of each sequence <= 8*10^9
  gq58x4_skipahead_(state,0,8799201913ULL*(unsigned long long)SequenceNumber);
}

__device__ __host__ void gq58x4_init_long_sequence_(gq58x4_state* state,unsigned SequenceNumber){
  gq58x4_init_(state);                     // 0 <= SequenceNumber < 3*10^4;   length of each sequence <= 8*10^11
  gq58x4_skipahead_(state,0,828317697521ULL*(unsigned long long)SequenceNumber);
}

__device__ __host__ unsigned int gq58x4_generate_(gq58x4_state* state){
  unsigned int sum=0; int i; lt temp;
  for(i=0;i<8;i++){ 
    temp=gq58x4_mod_g((state->xN[i]+6*(gq58x4_g-state->xP[i]))<<3);
    state->xP[i]=state->xN[i]; state->xN[i]=temp;
    sum+= ((temp/gq58x4_gdiv16)<<((i<4)?(8*i):(8*i-28)));
  }
  return sum;
}

__device__ __host__ float gq58x4_generate_uniform_float_(gq58x4_state* state){
  unsigned int sum=0; int i; lt temp;
  for(i=0;i<8;i++){ 
    temp=gq58x4_mod_g((state->xN[i]+6*(gq58x4_g-state->xP[i]))<<3);
    state->xP[i]=state->xN[i]; state->xN[i]=temp;
    sum+= ((temp/gq58x4_gdiv16)<<((i<4)?(8*i):(8*i-28)));
  }
  return ((float) sum) * 2.3283064365386963e-10;
}

__host__ void gq58x4_print_state_(gq58x4_state* state){int i;
    printf("Generator State:\nxN={");
    for(i=0;i<8;i++) {printf("%llu",state->xN[i]%gq58x4_g); printf((i<7)?",":"}\nxP={");}
    for(i=0;i<8;i++) {printf("%llu",state->xP[i]%gq58x4_g); printf((i<7)?",":"}\n\n");}
}

__host__ void gq58x4_print_sse_state_(gq58x4_sse_state* state){int i;
    printf("Generator State:\nxN={");
    for(i=0;i<8;i++) {printf("%llu",state->xN[i]%gq58x4_g); printf((i<7)?",":"}\nxP={");}
    for(i=0;i<8;i++) {printf("%llu",state->xP[i]%gq58x4_g); printf((i<7)?",":"}\n\n");}
}

__global__ void gq58x4_kernel_generate_array(gq58x4_state* state, unsigned int* out, long* length) {
    unsigned sum,i,j,orbit,seqNum,shift; long offset; lt temp;

    __shared__ lt xP[gq58x4_THREADS];        // one generator per s=8 threads, i.e. one orbit
    __shared__ lt xN[gq58x4_THREADS];        // per thread, i.e. blockDim.x orbits per block
    __shared__ unsigned  a[gq58x4_THREADS];  // array "a" contains corresponding parts of output

    orbit   = threadIdx.x % 8;
    seqNum  = (threadIdx.x + blockIdx.x * blockDim.x)>>3;  // RNG_sequence index
    offset  = seqNum*(*length);                            // start of the section in the output array

    xP[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset);
    xN[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset+1);

    shift=((orbit<4)?(8*orbit):(8*orbit-28));

    for(i=0;i<(*length);i++){

      temp = gq58x4_CNext( xN[threadIdx.x], xP[threadIdx.x] );
      xP[threadIdx.x] = xN[threadIdx.x]; xN[threadIdx.x] = temp; 
      a[threadIdx.x]  = ((temp/gq58x4_gdiv16)<<shift);

      __syncthreads();              // each s=8 threads result in "length" values in the output array

      if(orbit==0){ sum=0; for(j=0;j<8;j++) sum+=a[threadIdx.x+j]; out[offset+i]=sum; }

    }
}

__host__ void gq58x4_generate_gpu_array_(gq58x4_state* state, unsigned int* dev_out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_state,state,sizeof(gq58x4_state),cudaMemcpyHostToDevice));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_length,&mylength,sizeof(long),cudaMemcpyHostToDevice));

   gq58x4_kernel_generate_array<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(cudaGetLastError());
   
   gq58x4_CUDA_CALL(cudaFree(dev_state)); gq58x4_CUDA_CALL(cudaFree(dev_length));

}

__global__ void gq58x4_kernel_generate_array_float(gq58x4_state* state, float* out, long* length) {
    unsigned sum,i,j,orbit,seqNum,shift; long offset; lt temp;

    __shared__ lt xP[gq58x4_THREADS];        // one generator per s=8 threads, i.e. one orbit
    __shared__ lt xN[gq58x4_THREADS];        // per thread, i.e. blockDim.x orbits per block
    __shared__ unsigned  a[gq58x4_THREADS];  // array "a" contains corresponding parts of output

    orbit   = threadIdx.x % 8;
    seqNum  = (threadIdx.x + blockIdx.x * blockDim.x)>>3;  // RNG_sequence index
    offset  = seqNum*(*length);                            // start of the section in the output array

    xP[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset);
    xN[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset+1);

    shift=((orbit<4)?(8*orbit):(8*orbit-28));

    for(i=0;i<(*length);i++){

      temp = gq58x4_CNext( xN[threadIdx.x], xP[threadIdx.x] );
      xP[threadIdx.x] = xN[threadIdx.x]; xN[threadIdx.x] = temp; 
      a[threadIdx.x]  = ((temp/gq58x4_gdiv16)<<shift);

      __syncthreads();              // each s=8 threads result in "length" values in the output array

      if(orbit==0){ sum=0; for(j=0;j<8;j++) sum+=a[threadIdx.x+j]; out[offset+i]=((float)sum)* 2.3283064365386963e-10; }

    }
}

__host__ void gq58x4_generate_gpu_array_float_(gq58x4_state* state, float* dev_out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_state,state,sizeof(gq58x4_state),cudaMemcpyHostToDevice));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_length,&mylength,sizeof(long),cudaMemcpyHostToDevice));

   gq58x4_kernel_generate_array_float<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(cudaGetLastError());
   
   gq58x4_CUDA_CALL(cudaFree(dev_state)); gq58x4_CUDA_CALL(cudaFree(dev_length));

}

__global__ void gq58x4_kernel_generate_array_double(gq58x4_state* state, double* out, long* length) {
    unsigned sum,i,j,orbit,seqNum,shift; long offset; lt temp;

    __shared__ lt xP[gq58x4_THREADS];        // one generator per s=8 threads, i.e. one orbit
    __shared__ lt xN[gq58x4_THREADS];        // per thread, i.e. blockDim.x orbits per block
    __shared__ unsigned  a[gq58x4_THREADS];  // array "a" contains corresponding parts of output

    orbit   = threadIdx.x % 8;
    seqNum  = (threadIdx.x + blockIdx.x * blockDim.x)>>3;  // RNG_sequence index
    offset  = seqNum*(*length);                            // start of the section in the output array

    xP[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset);
    xN[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset+1);

    shift=((orbit<4)?(8*orbit):(8*orbit-28));

    for(i=0;i<(*length);i++){

      temp = gq58x4_CNext( xN[threadIdx.x], xP[threadIdx.x] );
      xP[threadIdx.x] = xN[threadIdx.x]; xN[threadIdx.x] = temp; 
      a[threadIdx.x]  = ((temp/gq58x4_gdiv16)<<shift);

      __syncthreads();              // each s=8 threads result in "length" values in the output array

      if(orbit==0){ sum=0; for(j=0;j<8;j++) sum+=a[threadIdx.x+j]; out[offset+i]=((double)sum)* 2.3283064365386963e-10; }

    }
}

__host__ void gq58x4_generate_gpu_array_double_(gq58x4_state* state, double* dev_out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_state,state,sizeof(gq58x4_state),cudaMemcpyHostToDevice));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_length,&mylength,sizeof(long),cudaMemcpyHostToDevice));

   gq58x4_kernel_generate_array_double<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(cudaGetLastError());
   
   gq58x4_CUDA_CALL(cudaFree(dev_state)); gq58x4_CUDA_CALL(cudaFree(dev_length));

}

__host__ void gq58x4_generate_array_(gq58x4_state* state, unsigned int* out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   unsigned int* dev_out;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_out,mylength*gq58x4_ARRAY_SECTIONS*sizeof(unsigned int)));
   gq58x4_CUDA_CALL(cudaMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_state,state,sizeof(gq58x4_state),cudaMemcpyHostToDevice));
   gq58x4_CUDA_CALL(cudaMemcpy(dev_length,&mylength,sizeof(long),cudaMemcpyHostToDevice));

   gq58x4_kernel_generate_array<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(cudaGetLastError());
   
   gq58x4_CUDA_CALL(cudaMemcpy(out,dev_out,length*sizeof(unsigned int),cudaMemcpyDeviceToHost));
   gq58x4_CUDA_CALL(cudaFree(dev_state)); gq58x4_CUDA_CALL(cudaFree(dev_out)); 
   gq58x4_CUDA_CALL(cudaFree(dev_length));

}

	.file	"tmpxft_002d7798_00000000-6__gq58x4.cudafe1.cpp"
	.text
#APP

#NO_APP
	.type	_ZL26__cudaUnregisterBinaryUtilv, @function
_ZL26__cudaUnregisterBinaryUtilv:
.LFB2050:
	.cfi_startproc
	endbr64
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	jmp	__cudaUnregisterFatBinary@PLT
	.cfi_endproc
.LFE2050:
	.size	_ZL26__cudaUnregisterBinaryUtilv, .-_ZL26__cudaUnregisterBinaryUtilv
	.globl	_Z20gq58x4_sse_generate_P12gq58x4_state
	.type	_Z20gq58x4_sse_generate_P12gq58x4_state, @function
_Z20gq58x4_sse_generate_P12gq58x4_state:
.LFB2027:
	.cfi_startproc
	endbr64
	leaq	64(%rdi), %rdx
	leaq	gq58x4_sse_Consts(%rip), %rcx
#APP
# 34 "/home/ubuntu/Datasets/stackv2/train-structured/sbinet-staging/3photons/master/Random/aesb_v1_0/source/_gq58x4.cu" 1
	movaps (%rcx),%xmm0
movaps (%rdx),%xmm1
movaps (%rdi),%xmm4
movaps %xmm4,(%rdx)
psllq  $3,%xmm4
paddq  %xmm0,%xmm4
psllq  $4,%xmm1
psubq  %xmm1,%xmm4
psllq  $1,%xmm1
psubq  %xmm1,%xmm4
movaps %xmm4,%xmm1
psrlq  $58,%xmm1
psllq  $29,%xmm1
movaps %xmm1,%xmm3
psllq  $1,%xmm3
paddq  %xmm1,%xmm3
psllq  $29,%xmm1
psubq  %xmm1,%xmm4
paddq  %xmm3,%xmm4
movaps %xmm4,%xmm1
paddq  16(%rcx),%xmm1
pshufd $245,%xmm1,%xmm3
pcmpgtd 32(%rcx),%xmm3
pand    48(%rcx),%xmm3
psubq   %xmm3,%xmm4
movaps %xmm4,(%rdi)
movaps %xmm4,%xmm1
paddq  %xmm4,%xmm1
paddq  %xmm4,%xmm1
psrlq  $29,%xmm1
paddq  %xmm1,%xmm4
movaps 16(%rdx),%xmm1
movaps 16(%rdi),%xmm5
movaps %xmm5,16(%rdx)
psllq  $3,%xmm5
paddq  %xmm0,%xmm5
psllq  $4,%xmm1
psubq  %xmm1,%xmm5
psllq  $1,%xmm1
psubq  %xmm1,%xmm5
movaps %xmm5,%xmm1
psrlq  $58,%xmm1
psllq  $29,%xmm1
movaps %xmm1,%xmm3
psllq  $1,%xmm3
paddq  %xmm1,%xmm3
psllq  $29,%xmm1
psubq  %xmm1,%xmm5
paddq  %xmm3,%xmm5
movaps %xmm5,%xmm1
paddq  16(%rcx),%xmm1
pshufd $245,%xmm1,%xmm3
pcmpgtd 32(%rcx),%xmm3
pand    48(%rcx),%xmm3
psubq   %xmm3,%xmm5
movaps %xmm5,16(%rdi)
movaps %xmm5,%xmm1
paddq  %xmm5,%xmm1
paddq  %xmm5,%xmm1
psrlq  $29,%xmm1
paddq  %xmm1,%xmm5
movaps 32(%rdx),%xmm1
movaps 32(%rdi),%xmm6
movaps %xmm6,32(%rdx)
psllq  $3,%xmm6
paddq  %xmm0,%xmm6
psllq  $4,%xmm1
psubq  %xmm1,%xmm6
psllq  $1,%xmm1
psubq  %xmm1,%xmm6
movaps %xmm6,%xmm1
psrlq  $58,%xmm1
psllq  $29,%xmm1
movaps %xmm1,%xmm3
psllq  $1,%xmm3
paddq  %xmm1,%xmm3
psllq  $29,%xmm1
psubq  %xmm1,%xmm6
paddq  %xmm3,%xmm6
movaps %xmm6,%xmm1
paddq  16(%rcx),%xmm1
pshufd $245,%xmm1,%xmm3
pcmpgtd 32(%rcx),%xmm3
pand    48(%rcx),%xmm3
psubq   %xmm3,%xmm6
movaps %xmm6,32(%rdi)
movaps %xmm6,%xmm1
paddq  %xmm6,%xmm1
paddq  %xmm6,%xmm1
psrlq  $29,%xmm1
paddq  %xmm1,%xmm6
movaps 48(%rdx),%xmm1
movaps 48(%rdi),%xmm7
movaps %xmm7,48(%rdx)
psllq  $3,%xmm7
paddq  %xmm0,%xmm7
psllq  $4,%xmm1
psubq  %xmm1,%xmm7
psllq  $1,%xmm1
psubq  %xmm1,%xmm7
movaps %xmm7,%xmm1
psrlq  $58,%xmm1
psllq  $29,%xmm1
movaps %xmm1,%xmm3
psllq  $1,%xmm3
paddq  %xmm1,%xmm3
psllq  $29,%xmm1
psubq  %xmm1,%xmm7
paddq  %xmm3,%xmm7
movaps %xmm7,%xmm1
paddq  16(%rcx),%xmm1
pshufd $245,%xmm1,%xmm3
pcmpgtd 32(%rcx),%xmm3
pand    48(%rcx),%xmm3
psubq   %xmm3,%xmm7
movaps %xmm7,48(%rdi)
movaps %xmm7,%xmm1
paddq  %xmm7,%xmm1
paddq  %xmm7,%xmm1
psrlq  $29,%xmm1
paddq  %xmm1,%xmm7
psrlq  $54,%xmm4
psrlq  $54,%xmm5
psrlq  $54,%xmm6
psrlq  $54,%xmm7
packssdw  %xmm5,%xmm4
packssdw  %xmm7,%xmm6
packssdw  %xmm6,%xmm4
packsswb  %xmm4,%xmm4
movaps  %xmm4,%xmm0
psrldq   $4,%xmm0
pslld    $4,%xmm0
pxor    %xmm0,%xmm4
movd    %xmm4,%eax

# 0 "" 2
#NO_APP
	ret
	.cfi_endproc
.LFE2027:
	.size	_Z20gq58x4_sse_generate_P12gq58x4_state, .-_Z20gq58x4_sse_generate_P12gq58x4_state
	.globl	_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_
	.type	_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_, @function
_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_:
.LFB2028:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	movq	%rdi, %rbx
	movl	$64, %edx
	movq	%rsi, %rdi
	movq	%rbx, %rsi
	call	memmove@PLT
	leaq	64(%rbx), %rsi
	movl	$64, %edx
	popq	%rbx
	.cfi_def_cfa_offset 8
	movq	%rax, %rdi
	addq	$64, %rdi
	jmp	memmove@PLT
	.cfi_endproc
.LFE2028:
	.size	_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_, .-_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_
	.globl	_Z12gq58x4_mod_gy
	.type	_Z12gq58x4_mod_gy, @function
_Z12gq58x4_mod_gy:
.LFB2029:
	.cfi_startproc
	endbr64
	movabsq	$288230376151711743, %rdx
	movq	%rdi, %rax
	shrq	$58, %rax
	andq	%rdx, %rdi
	subq	$1610612736, %rdx
	imulq	$1610612736, %rax, %rax
	addq	%rdi, %rax
	cmpq	%rax, %rdx
	jnb	.L5
	movabsq	$-288230374541099008, %rdx
	addq	%rdx, %rax
.L5:
	ret
	.cfi_endproc
.LFE2029:
	.size	_Z12gq58x4_mod_gy, .-_Z12gq58x4_mod_gy
	.globl	_Z13gq58x4_MyMultyy
	.type	_Z13gq58x4_MyMultyy, @function
_Z13gq58x4_MyMultyy:
.LFB2030:
	.cfi_startproc
	endbr64
	movq	%rdi, %rcx
	movq	%rsi, %r9
	movl	%edi, %edi
	movl	%esi, %esi
	shrq	$32, %rcx
	shrq	$32, %r9
	imulq	$12, %rcx, %rax
	imulq	$12, %r9, %rdx
	addq	%rax, %rdi
	movq	%rdi, %rax
	addq	%rsi, %rdx
	shrq	$32, %rax
	je	.L9
	movabsq	$-4294967284, %rax
	incq	%rcx
	addq	%rax, %rdi
.L9:
	movq	%rdx, %rax
	shrq	$32, %rax
	je	.L10
	movabsq	$-4294967284, %rax
	incq	%r9
	addq	%rax, %rdx
.L10:
	movq	%rcx, %rax
	imulq	%r9, %rcx
	movq	%rdi, %rsi
	imulq	%rdx, %rax
	imulq	%r9, %rsi
	imulq	%rdx, %rdi
	imulq	$144, %rcx, %rcx
	addq	%rsi, %rax
	movq	%rax, %r8
	shrq	$26, %rax
	andl	$67108863, %r8d
	leaq	(%rax,%rax,2), %rsi
	movq	%r8, %rax
	imulq	$12, %r8, %r8
	salq	$4, %rax
	addq	%rax, %rsi
	call	_Z12gq58x4_mod_gy
	movl	$536870909, %edx
	salq	$28, %rsi
	salq	$29, %rdx
	addq	%rdx, %rax
	leaq	(%rcx,%rax), %rdi
	movq	%rdi, %rcx
	subq	%r8, %rcx
	leaq	(%rcx,%rsi), %rdi
	jmp	_Z12gq58x4_mod_gy
	.cfi_endproc
.LFE2030:
	.size	_Z13gq58x4_MyMultyy, .-_Z13gq58x4_MyMultyy
	.globl	_Z13gq58x4_CNext2yyyy
	.type	_Z13gq58x4_CNext2yyyy, @function
_Z13gq58x4_CNext2yyyy:
.LFB2031:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	movq	%rdi, %rax
	movq	%rcx, %r11
	movq	%rdx, %rdi
	movq	%rsi, %rbx
	movq	%rax, %rsi
	call	_Z13gq58x4_MyMultyy
	movq	%rbx, %rsi
	movq	%r11, %rdi
	movq	%rax, %r10
	call	_Z13gq58x4_MyMultyy
	movq	%rax, %rdx
	cmpq	%rax, %r10
	jnb	.L21
	movl	$536870909, %eax
	salq	$29, %rax
	addq	%rax, %r10
.L21:
	subq	%rdx, %r10
	popq	%rbx
	.cfi_def_cfa_offset 8
	movq	%r10, %rax
	ret
	.cfi_endproc
.LFE2031:
	.size	_Z13gq58x4_CNext2yyyy, .-_Z13gq58x4_CNext2yyyy
	.globl	_Z12gq58x4_CNextyy
	.type	_Z12gq58x4_CNextyy, @function
_Z12gq58x4_CNextyy:
.LFB2032:
	.cfi_startproc
	endbr64
	imulq	$-6, %rsi, %rsi
	movl	$1610612727, %eax
	salq	$30, %rax
	addq	%rax, %rdi
	addq	%rdi, %rsi
	leaq	0(,%rsi,8), %rdi
	jmp	_Z12gq58x4_mod_gy
	.cfi_endproc
.LFE2032:
	.size	_Z12gq58x4_CNextyy, .-_Z12gq58x4_CNextyy
	.globl	_Z15gq58x4_GetNextNyyj
	.type	_Z15gq58x4_GetNextNyyj, @function
_Z15gq58x4_GetNextNyyj:
.LFB2033:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	xorl	%r15d, %r15d
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	movl	%edx, %r14d
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	movq	%rdi, %r13
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	movl	$8, %r12d
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	movl	$48, %ebp
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	movq	%rsi, %rbx
.L24:
	cmpq	%r14, %r15
	jnb	.L27
	movq	%rbp, %rcx
	movq	%r12, %rdx
	movq	%rbx, %rdi
	movq	%r13, %rsi
	call	_Z13gq58x4_CNext2yyyy
	movq	%rbp, %rcx
	movq	%r12, %rdx
	movq	%r12, %rdi
	movl	$2, %esi
	movq	%rax, %rbx
	incq	%r15
	call	_Z13gq58x4_CNext2yyyy
	movq	%rbp, %rdx
	movq	%rbp, %rdi
	xorl	%ecx, %ecx
	xorl	%esi, %esi
	movq	%rax, %r12
	call	_Z13gq58x4_CNext2yyyy
	movq	%rax, %rbp
	jmp	.L24
.L27:
	movq	%rbx, %rax
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2033:
	.size	_Z15gq58x4_GetNextNyyj, .-_Z15gq58x4_GetNextNyyj
	.globl	_Z17gq58x4_GetNextAnyyyyy
	.type	_Z17gq58x4_GetNextAnyyyyy, @function
_Z17gq58x4_GetNextAnyyyyy:
.LFB2034:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	xorl	%r14d, %r14d
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	movq	%rcx, %r13
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	movq	%rdx, %r12
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	movq	%rdi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	movq	%rsi, %rbx
	pushq	%r8
	.cfi_def_cfa_offset 64
.L29:
	testq	%r13, %r13
	je	.L42
	testl	$1, %r13d
	je	.L30
	movl	%r14d, %edx
	movq	%rbx, %rsi
	movq	%rbp, %rdi
	movl	%r14d, 4(%rsp)
	call	_Z15gq58x4_GetNextNyyj
	movq	%rbp, %rsi
	movq	%rbx, %rdi
	movq	%rax, %r15
	call	_Z12gq58x4_CNextyy
	movq	%rbx, %rdi
	movl	%r14d, %edx
	movq	%r15, %rbp
	movq	%rax, %rsi
	call	_Z15gq58x4_GetNextNyyj
	movq	%rax, %rbx
.L30:
	shrq	%r13
	incq	%r14
	jmp	.L29
.L42:
	movl	$64, %r13d
.L32:
	testq	%r12, %r12
	je	.L43
	testl	$1, %r12d
	je	.L33
	movl	%r13d, %edx
	movq	%rbx, %rsi
	movq	%rbp, %rdi
	call	_Z15gq58x4_GetNextNyyj
	movq	%rbp, %rsi
	movq	%rbx, %rdi
	movq	%rax, %r14
	call	_Z12gq58x4_CNextyy
	movq	%rbx, %rdi
	movl	%r13d, %edx
	movq	%r14, %rbp
	movq	%rax, %rsi
	call	_Z15gq58x4_GetNextNyyj
	movq	%rax, %rbx
.L33:
	shrq	%r12
	incq	%r13
	jmp	.L32
.L43:
	popq	%rdx
	.cfi_def_cfa_offset 56
	movq	%rbp, %rax
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2034:
	.size	_Z17gq58x4_GetNextAnyyyyy, .-_Z17gq58x4_GetNextAnyyyyy
	.globl	_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.type	_Z17gq58x4_skipahead_P12gq58x4_stateyy, @function
_Z17gq58x4_skipahead_P12gq58x4_stateyy:
.LFB2035:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	leaq	1(%rdx), %r15
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	movq	%rdx, %r13
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	movq	%rsi, %r12
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	movq	%rdi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	xorl	%ebx, %ebx
	subq	$16, %rsp
	.cfi_def_cfa_offset 72
.L45:
	movq	0(%rbp,%rbx,8), %rsi
	movq	64(%rbp,%rbx,8), %rdi
	movq	%r13, %rcx
	movq	%r12, %rdx
	movq	%rsi, 8(%rsp)
	movq	%rdi, (%rsp)
	call	_Z17gq58x4_GetNextAnyyyyy
	movq	8(%rsp), %rsi
	movq	%r15, %rcx
	movq	%r12, %rdx
	movq	(%rsp), %rdi
	movq	%rax, %r14
	call	_Z17gq58x4_GetNextAnyyyyy
	movq	%r14, 64(%rbp,%rbx,8)
	movq	%rax, 0(%rbp,%rbx,8)
	incq	%rbx
	cmpq	$8, %rbx
	jne	.L45
	addq	$16, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2035:
	.size	_Z17gq58x4_skipahead_P12gq58x4_stateyy, .-_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.globl	_Z12gq58x4_init_P12gq58x4_state
	.type	_Z12gq58x4_init_P12gq58x4_state, @function
_Z12gq58x4_init_P12gq58x4_state:
.LFB2036:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	movabsq	$35048736516210783, %r14
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	movq	%rdi, %r13
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	movabsq	$100152853817629549, %r12
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	xorl	%ebp, %ebp
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	movabsq	$132388305121829306, %rbx
.L49:
	movq	%rbx, %rsi
	movq	%r12, %rdi
	movq	%r12, %r15
	movq	%r14, %rcx
	xorl	%edx, %edx
	call	_Z17gq58x4_GetNextAnyyyyy
	movq	%rbx, %rsi
	xorl	%edx, %edx
	movq	%r15, %rdi
	movabsq	$35048736516210784, %rcx
	movq	%rax, %r12
	call	_Z17gq58x4_GetNextAnyyyyy
	movq	%r12, 64(%r13,%rbp,8)
	movq	%rax, 0(%r13,%rbp,8)
	incq	%rbp
	movq	%rax, %rbx
	cmpq	$8, %rbp
	jne	.L49
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2036:
	.size	_Z12gq58x4_init_P12gq58x4_state, .-_Z12gq58x4_init_P12gq58x4_state
	.globl	_Z27gq58x4_init_short_sequence_P12gq58x4_statej
	.type	_Z27gq58x4_init_short_sequence_P12gq58x4_statej, @function
_Z27gq58x4_init_short_sequence_P12gq58x4_statej:
.LFB2037:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	movl	%esi, %ebx
	pushq	%rax
	.cfi_def_cfa_offset 24
	movq	%rdi, (%rsp)
	call	_Z12gq58x4_init_P12gq58x4_state
	movl	%ebx, %edx
	movq	(%rsp), %rdi
	xorl	%esi, %esi
	imulq	$82927047, %rdx, %rdx
	popq	%rcx
	.cfi_def_cfa_offset 16
	popq	%rbx
	.cfi_def_cfa_offset 8
	jmp	_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.cfi_endproc
.LFE2037:
	.size	_Z27gq58x4_init_short_sequence_P12gq58x4_statej, .-_Z27gq58x4_init_short_sequence_P12gq58x4_statej
	.globl	_Z28gq58x4_init_medium_sequence_P12gq58x4_statej
	.type	_Z28gq58x4_init_medium_sequence_P12gq58x4_statej, @function
_Z28gq58x4_init_medium_sequence_P12gq58x4_statej:
.LFB2038:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	movl	%esi, %ebx
	pushq	%rax
	.cfi_def_cfa_offset 24
	movq	%rdi, (%rsp)
	call	_Z12gq58x4_init_P12gq58x4_state
	movl	%ebx, %edx
	movq	(%rsp), %rdi
	xorl	%esi, %esi
	movabsq	$8799201913, %rax
	popq	%rcx
	.cfi_def_cfa_offset 16
	popq	%rbx
	.cfi_def_cfa_offset 8
	imulq	%rax, %rdx
	jmp	_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.cfi_endproc
.LFE2038:
	.size	_Z28gq58x4_init_medium_sequence_P12gq58x4_statej, .-_Z28gq58x4_init_medium_sequence_P12gq58x4_statej
	.globl	_Z26gq58x4_init_long_sequence_P12gq58x4_statej
	.type	_Z26gq58x4_init_long_sequence_P12gq58x4_statej, @function
_Z26gq58x4_init_long_sequence_P12gq58x4_statej:
.LFB2039:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	movl	%esi, %ebx
	pushq	%rax
	.cfi_def_cfa_offset 24
	movq	%rdi, (%rsp)
	call	_Z12gq58x4_init_P12gq58x4_state
	movl	%ebx, %edx
	movq	(%rsp), %rdi
	xorl	%esi, %esi
	movabsq	$828317697521, %rax
	popq	%rcx
	.cfi_def_cfa_offset 16
	popq	%rbx
	.cfi_def_cfa_offset 8
	imulq	%rax, %rdx
	jmp	_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.cfi_endproc
.LFE2039:
	.size	_Z26gq58x4_init_long_sequence_P12gq58x4_statej, .-_Z26gq58x4_init_long_sequence_P12gq58x4_statej
	.globl	_Z16gq58x4_generate_P12gq58x4_state
	.type	_Z16gq58x4_generate_P12gq58x4_state, @function
_Z16gq58x4_generate_P12gq58x4_state:
.LFB2040:
	.cfi_startproc
	endbr64
	movq	%rdi, %r8
	xorl	%esi, %esi
	xorl	%r9d, %r9d
	movabsq	$1729382247246594048, %r11
	movabsq	$18014398408818688, %r10
.L61:
	movq	(%r8,%rsi,8), %rcx
	imulq	$-6, 64(%r8,%rsi,8), %rdi
	leaq	(%rcx,%r11), %rax
	addq	%rax, %rdi
	salq	$3, %rdi
	call	_Z12gq58x4_mod_gy
	xorl	%edx, %edx
	movq	%rcx, 64(%r8,%rsi,8)
	movq	%rax, (%r8,%rsi,8)
	divq	%r10
	leal	0(,%rsi,8), %edx
	cmpq	$3, %rsi
	leal	-28(%rdx), %ecx
	cmovbe	%edx, %ecx
	incq	%rsi
	salq	%cl, %rax
	addl	%eax, %r9d
	cmpq	$8, %rsi
	jne	.L61
	movl	%r9d, %eax
	ret
	.cfi_endproc
.LFE2040:
	.size	_Z16gq58x4_generate_P12gq58x4_state, .-_Z16gq58x4_generate_P12gq58x4_state
	.globl	_Z30gq58x4_generate_uniform_float_P12gq58x4_state
	.type	_Z30gq58x4_generate_uniform_float_P12gq58x4_state, @function
_Z30gq58x4_generate_uniform_float_P12gq58x4_state:
.LFB2041:
	.cfi_startproc
	endbr64
	movq	%rdi, %r8
	xorl	%esi, %esi
	xorl	%r9d, %r9d
	movabsq	$1729382247246594048, %r11
	movabsq	$18014398408818688, %r10
.L66:
	movq	(%r8,%rsi,8), %rcx
	imulq	$-6, 64(%r8,%rsi,8), %rdi
	leaq	(%rcx,%r11), %rax
	addq	%rax, %rdi
	salq	$3, %rdi
	call	_Z12gq58x4_mod_gy
	xorl	%edx, %edx
	movq	%rcx, 64(%r8,%rsi,8)
	movq	%rax, (%r8,%rsi,8)
	divq	%r10
	leal	0(,%rsi,8), %edx
	cmpq	$3, %rsi
	leal	-28(%rdx), %ecx
	cmovbe	%edx, %ecx
	incq	%rsi
	salq	%cl, %rax
	addl	%eax, %r9d
	cmpq	$8, %rsi
	jne	.L66
	cvtsi2ssq	%r9, %xmm0
	mulss	.LC0(%rip), %xmm0
	ret
	.cfi_endproc
.LFE2041:
	.size	_Z30gq58x4_generate_uniform_float_P12gq58x4_state, .-_Z30gq58x4_generate_uniform_float_P12gq58x4_state
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC1:
	.string	","
.LC2:
	.string	"}\nxP={"
.LC3:
	.string	"}\n\n"
.LC4:
	.string	"Generator State:\nxN={"
.LC5:
	.string	"%llu"
	.text
	.globl	_Z19gq58x4_print_state_P12gq58x4_state
	.type	_Z19gq58x4_print_state_P12gq58x4_state, @function
_Z19gq58x4_print_state_P12gq58x4_state:
.LFB2042:
	.cfi_startproc
	endbr64
	pushq	%r13
	.cfi_def_cfa_offset 16
	.cfi_offset 13, -16
	leaq	.LC4(%rip), %rsi
	xorl	%eax, %eax
	movabsq	$288230374541099008, %r13
	pushq	%r12
	.cfi_def_cfa_offset 24
	.cfi_offset 12, -24
	pushq	%rbp
	.cfi_def_cfa_offset 32
	.cfi_offset 6, -32
	movq	%rdi, %rbp
	movl	$2, %edi
	pushq	%rbx
	.cfi_def_cfa_offset 40
	.cfi_offset 3, -40
	xorl	%ebx, %ebx
	pushq	%rdx
	.cfi_def_cfa_offset 48
	call	__printf_chk@PLT
.L72:
	movq	0(%rbp,%rbx,8), %rax
	xorl	%edx, %edx
	movl	$2, %edi
	leaq	.LC5(%rip), %r12
	movq	%r12, %rsi
	divq	%r13
	xorl	%eax, %eax
	call	__printf_chk@PLT
	cmpq	$7, %rbx
	movl	$2, %edi
	leaq	.LC1(%rip), %rax
	leaq	.LC2(%rip), %rsi
	cmovne	%rax, %rsi
	xorl	%eax, %eax
	incq	%rbx
	call	__printf_chk@PLT
	cmpq	$8, %rbx
	jne	.L72
	movabsq	$288230374541099008, %r13
	xorl	%ebx, %ebx
.L74:
	movq	64(%rbp,%rbx,8), %rax
	xorl	%edx, %edx
	movq	%r12, %rsi
	movl	$2, %edi
	divq	%r13
	xorl	%eax, %eax
	call	__printf_chk@PLT
	cmpq	$7, %rbx
	movl	$2, %edi
	leaq	.LC1(%rip), %rax
	leaq	.LC3(%rip), %rsi
	cmovne	%rax, %rsi
	xorl	%eax, %eax
	incq	%rbx
	call	__printf_chk@PLT
	cmpq	$8, %rbx
	jne	.L74
	popq	%rax
	.cfi_def_cfa_offset 40
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%rbp
	.cfi_def_cfa_offset 24
	popq	%r12
	.cfi_def_cfa_offset 16
	popq	%r13
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2042:
	.size	_Z19gq58x4_print_state_P12gq58x4_state, .-_Z19gq58x4_print_state_P12gq58x4_state
	.globl	_Z23gq58x4_print_sse_state_P12gq58x4_state
	.type	_Z23gq58x4_print_sse_state_P12gq58x4_state, @function
_Z23gq58x4_print_sse_state_P12gq58x4_state:
.LFB2196:
	.cfi_startproc
	endbr64
	jmp	_Z19gq58x4_print_state_P12gq58x4_state
	.cfi_endproc
.LFE2196:
	.size	_Z23gq58x4_print_sse_state_P12gq58x4_state, .-_Z23gq58x4_print_sse_state_P12gq58x4_state
	.globl	_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl
	.type	_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl, @function
_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl:
.LFB2072:
	.cfi_startproc
	endbr64
	subq	$136, %rsp
	.cfi_def_cfa_offset 144
	movq	%rdi, 24(%rsp)
	leaq	40(%rsp), %rcx
	leaq	48(%rsp), %rdi
	movq	%rsi, 16(%rsp)
	leaq	60(%rsp), %rsi
	movq	%rdx, 8(%rsp)
	leaq	32(%rsp), %rdx
	movq	%fs:40, %rax
	movq	%rax, 120(%rsp)
	xorl	%eax, %eax
	leaq	24(%rsp), %rax
	movl	$1, 56(%rsp)
	movq	%rax, 96(%rsp)
	leaq	16(%rsp), %rax
	movq	%rax, 104(%rsp)
	leaq	8(%rsp), %rax
	movq	%rax, 112(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 48(%rsp)
	movq	%rax, 60(%rsp)
	movl	$1, 68(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L81
	pushq	40(%rsp)
	.cfi_def_cfa_offset 152
	leaq	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl(%rip), %rdi
	pushq	40(%rsp)
	.cfi_def_cfa_offset 160
	movq	76(%rsp), %rcx
	movl	84(%rsp), %r8d
	movq	64(%rsp), %rsi
	movl	72(%rsp), %edx
	leaq	112(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 152
	popq	%rdx
	.cfi_def_cfa_offset 144
.L81:
	movq	120(%rsp), %rax
	subq	%fs:40, %rax
	je	.L83
	call	__stack_chk_fail@PLT
.L83:
	addq	$136, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2072:
	.size	_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl, .-_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl
	.globl	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.type	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, @function
_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl:
.LFB2073:
	.cfi_startproc
	endbr64
	jmp	_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl
	.cfi_endproc
.LFE2073:
	.size	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, .-_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.section	.rodata.str1.1
.LC6:
	.string	"/home/ubuntu/Datasets/stackv2/train-structured/sbinet-staging/3photons/master/Random/aesb_v1_0/source/_gq58x4.cu"
.LC7:
	.string	"Error: %s at %s:%d\n"
	.text
	.globl	_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl
	.type	_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl, @function
_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl:
.LFB2044:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rdx, %rcx
	movq	%rdi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 24
	.cfi_offset 3, -24
	movq	%rsi, %rbx
	movl	$2048, %esi
	subq	$72, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 56(%rsp)
	xorl	%eax, %eax
	movq	%rdx, %rax
	cqto
	idivq	%rsi
	movq	%rax, %rdx
	salq	$11, %rdx
	cmpq	%rcx, %rdx
	jge	.L87
	incq	%rax
.L87:
	leaq	16(%rsp), %rdi
	movl	$128, %esi
	movq	%rax, 8(%rsp)
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L88
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$342, %r8d
	movq	%rax, %rdx
	jmp	.L98
.L88:
	leaq	24(%rsp), %rdi
	movl	$8, %esi
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L89
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$343, %r8d
	movq	%rax, %rdx
.L98:
	movl	$2, %edi
	leaq	.LC6(%rip), %rcx
	leaq	.LC7(%rip), %rsi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	$1, %edi
	call	exit@PLT
.L89:
	movq	16(%rsp), %rdi
	movl	$1, %ecx
	movl	$128, %edx
	movq	%rbp, %rsi
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L90
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$344, %r8d
	movq	%rax, %rdx
	jmp	.L98
.L90:
	movq	24(%rsp), %rdi
	leaq	8(%rsp), %rsi
	movl	$1, %ecx
	movl	$8, %edx
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L91
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$345, %r8d
	movq	%rax, %rdx
	jmp	.L98
.L91:
	movl	$33554433, %edi
	xorl	%r9d, %r9d
	xorl	%r8d, %r8d
	movl	$1, %ecx
	salq	$7, %rdi
	movl	$1, %esi
	movq	%rdi, %rdx
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L92
	movq	24(%rsp), %rdx
	movq	16(%rsp), %rdi
	movq	%rbx, %rsi
	call	_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl
.L92:
	call	cudaGetLastError@PLT
	testl	%eax, %eax
	je	.L93
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$348, %r8d
	movq	%rax, %rdx
	jmp	.L98
.L93:
	movq	16(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	jne	.L99
	movq	24(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	je	.L86
.L99:
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$350, %r8d
	movq	%rax, %rdx
	jmp	.L98
.L86:
	movq	56(%rsp), %rax
	subq	%fs:40, %rax
	je	.L96
	call	__stack_chk_fail@PLT
.L96:
	addq	$72, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2044:
	.size	_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl, .-_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl
	.globl	_Z22gq58x4_generate_array_P12gq58x4_statePjl
	.type	_Z22gq58x4_generate_array_P12gq58x4_statePjl, @function
_Z22gq58x4_generate_array_P12gq58x4_statePjl:
.LFB2047:
	.cfi_startproc
	endbr64
	pushq	%r12
	.cfi_def_cfa_offset 16
	.cfi_offset 12, -16
	movl	$2048, %ecx
	movq	%rdi, %r12
	pushq	%rbp
	.cfi_def_cfa_offset 24
	.cfi_offset 6, -24
	movq	%rsi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset 3, -32
	movq	%rdx, %rbx
	subq	$64, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 56(%rsp)
	xorl	%eax, %eax
	movq	%rdx, %rax
	cqto
	idivq	%rcx
	movq	%rax, %rdx
	salq	$11, %rdx
	cmpq	%rbx, %rdx
	jge	.L101
	incq	%rax
.L101:
	leaq	8(%rsp), %rdi
	movl	$128, %esi
	movq	%rax, (%rsp)
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L102
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$461, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L102:
	movq	(%rsp), %rsi
	leaq	16(%rsp), %rdi
	salq	$13, %rsi
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L103
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$462, %r8d
	movq	%rax, %rdx
.L115:
	movl	$2, %edi
	leaq	.LC6(%rip), %rcx
	leaq	.LC7(%rip), %rsi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	$1, %edi
	call	exit@PLT
.L103:
	leaq	24(%rsp), %rdi
	movl	$8, %esi
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L104
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$463, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L104:
	movq	8(%rsp), %rdi
	movl	$1, %ecx
	movl	$128, %edx
	movq	%r12, %rsi
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L105
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$464, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L105:
	movq	24(%rsp), %rdi
	movq	%rsp, %rsi
	movl	$1, %ecx
	movl	$8, %edx
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L106
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$465, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L106:
	movl	$33554433, %edi
	xorl	%r9d, %r9d
	xorl	%r8d, %r8d
	movl	$1, %ecx
	salq	$7, %rdi
	movl	$1, %esi
	movq	%rdi, %rdx
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L107
	movq	24(%rsp), %rdx
	movq	16(%rsp), %rsi
	movq	8(%rsp), %rdi
	call	_Z65__device_stub__Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPlP12gq58x4_statePjPl
.L107:
	call	cudaGetLastError@PLT
	testl	%eax, %eax
	je	.L108
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$468, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L108:
	movq	16(%rsp), %rsi
	leaq	0(,%rbx,4), %rdx
	movl	$2, %ecx
	movq	%rbp, %rdi
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L109
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$470, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L109:
	movq	8(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	jne	.L116
	movq	16(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	je	.L111
.L116:
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$471, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L111:
	movq	24(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	je	.L100
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$472, %r8d
	movq	%rax, %rdx
	jmp	.L115
.L100:
	movq	56(%rsp), %rax
	subq	%fs:40, %rax
	je	.L113
	call	__stack_chk_fail@PLT
.L113:
	addq	$64, %rsp
	.cfi_def_cfa_offset 32
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%rbp
	.cfi_def_cfa_offset 16
	popq	%r12
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2047:
	.size	_Z22gq58x4_generate_array_P12gq58x4_statePjl, .-_Z22gq58x4_generate_array_P12gq58x4_statePjl
	.globl	_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl
	.type	_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl, @function
_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl:
.LFB2074:
	.cfi_startproc
	endbr64
	subq	$136, %rsp
	.cfi_def_cfa_offset 144
	movq	%rdi, 24(%rsp)
	leaq	40(%rsp), %rcx
	leaq	48(%rsp), %rdi
	movq	%rsi, 16(%rsp)
	leaq	60(%rsp), %rsi
	movq	%rdx, 8(%rsp)
	leaq	32(%rsp), %rdx
	movq	%fs:40, %rax
	movq	%rax, 120(%rsp)
	xorl	%eax, %eax
	leaq	24(%rsp), %rax
	movl	$1, 56(%rsp)
	movq	%rax, 96(%rsp)
	leaq	16(%rsp), %rax
	movq	%rax, 104(%rsp)
	leaq	8(%rsp), %rax
	movq	%rax, 112(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 48(%rsp)
	movq	%rax, 60(%rsp)
	movl	$1, 68(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L117
	pushq	40(%rsp)
	.cfi_def_cfa_offset 152
	leaq	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl(%rip), %rdi
	pushq	40(%rsp)
	.cfi_def_cfa_offset 160
	movq	76(%rsp), %rcx
	movl	84(%rsp), %r8d
	movq	64(%rsp), %rsi
	movl	72(%rsp), %edx
	leaq	112(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 152
	popq	%rdx
	.cfi_def_cfa_offset 144
.L117:
	movq	120(%rsp), %rax
	subq	%fs:40, %rax
	je	.L119
	call	__stack_chk_fail@PLT
.L119:
	addq	$136, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2074:
	.size	_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl, .-_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl
	.globl	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.type	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, @function
_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl:
.LFB2075:
	.cfi_startproc
	endbr64
	jmp	_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl
	.cfi_endproc
.LFE2075:
	.size	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, .-_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.globl	_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl
	.type	_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl, @function
_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl:
.LFB2045:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rdx, %rcx
	movq	%rdi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 24
	.cfi_offset 3, -24
	movq	%rsi, %rbx
	movl	$2048, %esi
	subq	$72, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 56(%rsp)
	xorl	%eax, %eax
	movq	%rdx, %rax
	cqto
	idivq	%rsi
	movq	%rax, %rdx
	salq	$11, %rdx
	cmpq	%rcx, %rdx
	jge	.L123
	incq	%rax
.L123:
	leaq	16(%rsp), %rdi
	movl	$128, %esi
	movq	%rax, 8(%rsp)
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L124
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$391, %r8d
	movq	%rax, %rdx
	jmp	.L134
.L124:
	leaq	24(%rsp), %rdi
	movl	$8, %esi
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L125
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$392, %r8d
	movq	%rax, %rdx
.L134:
	movl	$2, %edi
	leaq	.LC6(%rip), %rcx
	leaq	.LC7(%rip), %rsi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	$1, %edi
	call	exit@PLT
.L125:
	movq	16(%rsp), %rdi
	movl	$1, %ecx
	movl	$128, %edx
	movq	%rbp, %rsi
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L126
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$393, %r8d
	movq	%rax, %rdx
	jmp	.L134
.L126:
	movq	24(%rsp), %rdi
	leaq	8(%rsp), %rsi
	movl	$1, %ecx
	movl	$8, %edx
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L127
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$394, %r8d
	movq	%rax, %rdx
	jmp	.L134
.L127:
	movl	$33554433, %edi
	xorl	%r9d, %r9d
	xorl	%r8d, %r8d
	movl	$1, %ecx
	salq	$7, %rdi
	movl	$1, %esi
	movq	%rdi, %rdx
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L128
	movq	24(%rsp), %rdx
	movq	16(%rsp), %rdi
	movq	%rbx, %rsi
	call	_Z71__device_stub__Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPlP12gq58x4_statePfPl
.L128:
	call	cudaGetLastError@PLT
	testl	%eax, %eax
	je	.L129
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$397, %r8d
	movq	%rax, %rdx
	jmp	.L134
.L129:
	movq	16(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	jne	.L135
	movq	24(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	je	.L122
.L135:
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$399, %r8d
	movq	%rax, %rdx
	jmp	.L134
.L122:
	movq	56(%rsp), %rax
	subq	%fs:40, %rax
	je	.L132
	call	__stack_chk_fail@PLT
.L132:
	addq	$72, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2045:
	.size	_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl, .-_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl
	.globl	_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl
	.type	_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl, @function
_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl:
.LFB2076:
	.cfi_startproc
	endbr64
	subq	$136, %rsp
	.cfi_def_cfa_offset 144
	movq	%rdi, 24(%rsp)
	leaq	40(%rsp), %rcx
	leaq	48(%rsp), %rdi
	movq	%rsi, 16(%rsp)
	leaq	60(%rsp), %rsi
	movq	%rdx, 8(%rsp)
	leaq	32(%rsp), %rdx
	movq	%fs:40, %rax
	movq	%rax, 120(%rsp)
	xorl	%eax, %eax
	leaq	24(%rsp), %rax
	movl	$1, 56(%rsp)
	movq	%rax, 96(%rsp)
	leaq	16(%rsp), %rax
	movq	%rax, 104(%rsp)
	leaq	8(%rsp), %rax
	movq	%rax, 112(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 48(%rsp)
	movq	%rax, 60(%rsp)
	movl	$1, 68(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L136
	pushq	40(%rsp)
	.cfi_def_cfa_offset 152
	leaq	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl(%rip), %rdi
	pushq	40(%rsp)
	.cfi_def_cfa_offset 160
	movq	76(%rsp), %rcx
	movl	84(%rsp), %r8d
	movq	64(%rsp), %rsi
	movl	72(%rsp), %edx
	leaq	112(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 152
	popq	%rdx
	.cfi_def_cfa_offset 144
.L136:
	movq	120(%rsp), %rax
	subq	%fs:40, %rax
	je	.L138
	call	__stack_chk_fail@PLT
.L138:
	addq	$136, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2076:
	.size	_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl, .-_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl
	.globl	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.type	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, @function
_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl:
.LFB2077:
	.cfi_startproc
	endbr64
	jmp	_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl
	.cfi_endproc
.LFE2077:
	.size	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, .-_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.globl	_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl
	.type	_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl, @function
_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl:
.LFB2046:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rdx, %rcx
	movq	%rdi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 24
	.cfi_offset 3, -24
	movq	%rsi, %rbx
	movl	$2048, %esi
	subq	$72, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 56(%rsp)
	xorl	%eax, %eax
	movq	%rdx, %rax
	cqto
	idivq	%rsi
	movq	%rax, %rdx
	salq	$11, %rdx
	cmpq	%rcx, %rdx
	jge	.L142
	incq	%rax
.L142:
	leaq	16(%rsp), %rdi
	movl	$128, %esi
	movq	%rax, 8(%rsp)
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L143
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$440, %r8d
	movq	%rax, %rdx
	jmp	.L153
.L143:
	leaq	24(%rsp), %rdi
	movl	$8, %esi
	call	cudaMalloc@PLT
	testl	%eax, %eax
	je	.L144
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$441, %r8d
	movq	%rax, %rdx
.L153:
	movl	$2, %edi
	leaq	.LC6(%rip), %rcx
	leaq	.LC7(%rip), %rsi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	$1, %edi
	call	exit@PLT
.L144:
	movq	16(%rsp), %rdi
	movl	$1, %ecx
	movl	$128, %edx
	movq	%rbp, %rsi
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L145
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$442, %r8d
	movq	%rax, %rdx
	jmp	.L153
.L145:
	movq	24(%rsp), %rdi
	leaq	8(%rsp), %rsi
	movl	$1, %ecx
	movl	$8, %edx
	call	cudaMemcpy@PLT
	testl	%eax, %eax
	je	.L146
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$443, %r8d
	movq	%rax, %rdx
	jmp	.L153
.L146:
	movl	$33554433, %edi
	xorl	%r9d, %r9d
	xorl	%r8d, %r8d
	movl	$1, %ecx
	salq	$7, %rdi
	movl	$1, %esi
	movq	%rdi, %rdx
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L147
	movq	24(%rsp), %rdx
	movq	16(%rsp), %rdi
	movq	%rbx, %rsi
	call	_Z72__device_stub__Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPlP12gq58x4_statePdPl
.L147:
	call	cudaGetLastError@PLT
	testl	%eax, %eax
	je	.L148
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$446, %r8d
	movq	%rax, %rdx
	jmp	.L153
.L148:
	movq	16(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	jne	.L154
	movq	24(%rsp), %rdi
	call	cudaFree@PLT
	testl	%eax, %eax
	je	.L141
.L154:
	call	cudaGetLastError@PLT
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	$448, %r8d
	movq	%rax, %rdx
	jmp	.L153
.L141:
	movq	56(%rsp), %rax
	subq	%fs:40, %rax
	je	.L151
	call	__stack_chk_fail@PLT
.L151:
	addq	$72, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE2046:
	.size	_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl, .-_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl
	.section	.rodata.str1.1
.LC8:
	.string	"_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl"
.LC9:
	.string	"_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl"
.LC10:
	.string	"_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl"
	.section	.text.startup,"ax",@progbits
	.type	_ZL24__sti____cudaRegisterAllv, @function
_ZL24__sti____cudaRegisterAllv:
.LFB2079:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	leaq	_ZL15__fatDeviceText(%rip), %rdi
	call	__cudaRegisterFatBinary@PLT
	pushq	$0
	.cfi_def_cfa_offset 24
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC8(%rip), %rdx
	movq	%rax, %rdi
	movq	%rax, %rbx
	pushq	$0
	.cfi_def_cfa_offset 40
	movq	%rdx, %rcx
	leaq	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 48
	movq	%rax, _ZL20__cudaFatCubinHandle(%rip)
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	movq	%rbx, %rdi
	xorl	%r9d, %r9d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC9(%rip), %rdx
	orl	$-1, %r8d
	leaq	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	movq	%rbx, %rdi
	xorl	%r9d, %r9d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC10(%rip), %rdx
	orl	$-1, %r8d
	leaq	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	call	__cudaRegisterFatBinaryEnd@PLT
	leaq	_ZL26__cudaUnregisterBinaryUtilv(%rip), %rdi
	popq	%rbx
	.cfi_def_cfa_offset 8
	jmp	atexit@PLT
	.cfi_endproc
.LFE2079:
	.size	_ZL24__sti____cudaRegisterAllv, .-_ZL24__sti____cudaRegisterAllv
	.section	.init_array,"aw"
	.align 8
	.quad	_ZL24__sti____cudaRegisterAllv
	.section	.nvFatBinSegment,"aw"
	.align 8
	.type	_ZL15__fatDeviceText, @object
	.size	_ZL15__fatDeviceText, 24
_ZL15__fatDeviceText:
	.long	1180844977
	.long	1
	.quad	fatbinData
	.quad	0
	.local	_ZL20__cudaFatCubinHandle
	.comm	_ZL20__cudaFatCubinHandle,8,8
	.globl	gq58x4_sse_Consts
	.data
	.align 16
	.type	gq58x4_sse_Consts, @object
	.size	gq58x4_sse_Consts, 64
gq58x4_sse_Consts:
	.quad	-4611686095736799232
	.quad	-4611686095736799232
	.quad	1610612736
	.quad	1610612736
	.quad	288230371923853311
	.quad	288230371923853311
	.quad	288230374541099008
	.quad	288230374541099008
	.section	.rodata.cst4,"aM",@progbits,4
	.align 4
.LC0:
	.long	796917760
	.ident	"GCC: (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
0:
	.string	"GNU"
1:
	.align 8
	.long	0xc0000002
	.long	3f - 2f
2:
	.long	0x3
3:
	.align 8
4:

// (c) Copyright 2013 Lev Barash, Landau Institute for Theoretical Physics, Russian Academy of Sciences
// This is supplement to the paper:
// L.Yu. Barash, L.N. Shchur, "PRAND: GPU accelerated parallel random number generation library: Using most reliable algorithms and applying parallelism of modern GPUs and CPUs".
// e-mail: barash @ itp.ac.ru (remove space)


#include <hip/hip_runtime.h>
#include<stdio.h>

#define gq58x4_CUDA_CALL(x) do { if((x) != hipSuccess) { printf("Error: %s at %s:%d\n",hipGetErrorString(hipGetLastError()),__FILE__,__LINE__); exit(1);}} while(0)

#define gq58x4_BLOCKS  128
#define gq58x4_THREADS 128
#define gq58x4_ARRAY_SECTIONS (gq58x4_BLOCKS*gq58x4_THREADS/8)

#define gq58x4_k 8
#define gq58x4_q 48
#define gq58x4_g       288230374541099008ULL
#define gq58x4_gdiv16  18014398408818688ULL

typedef unsigned long long lt;

typedef struct{
  lt xN[8] __attribute__ ((aligned(16))),
     xP[8] __attribute__ ((aligned(16)));
} gq58x4_state;

typedef gq58x4_state gq58x4_sse_state;

lt gq58x4_sse_Consts[8] __attribute__ ((aligned(16))) =
   {13835057977972752384ULL,13835057977972752384ULL,1610612736ULL,1610612736ULL,
    288230371923853311ULL,288230371923853311ULL,288230374541099008ULL,288230374541099008ULL};

__host__ unsigned int gq58x4_sse_generate_(gq58x4_sse_state* state){
  unsigned output;
  asm volatile("movaps (%3),%%xmm0\n" \

      "movaps (%2),%%xmm1\n" \
      "movaps (%1),%%xmm4\n" \
      "movaps %%xmm4,(%2)\n" \
      "psllq  $3,%%xmm4\n" \
      "paddq  %%xmm0,%%xmm4\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm4\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm4\n" \
      "movaps %%xmm4,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm4\n" \
      "paddq  %%xmm3,%%xmm4\n" \
      "movaps %%xmm4,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm4\n" \
      "movaps %%xmm4,(%1)\n" \
      "movaps %%xmm4,%%xmm1\n" \
      "paddq  %%xmm4,%%xmm1\n" \
      "paddq  %%xmm4,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm4\n" \


      "movaps 16(%2),%%xmm1\n" \
      "movaps 16(%1),%%xmm5\n" \
      "movaps %%xmm5,16(%2)\n" \
      "psllq  $3,%%xmm5\n" \
      "paddq  %%xmm0,%%xmm5\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm5\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm5\n" \
      "movaps %%xmm5,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm5\n" \
      "paddq  %%xmm3,%%xmm5\n" \
      "movaps %%xmm5,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm5\n" \
      "movaps %%xmm5,16(%1)\n" \
      "movaps %%xmm5,%%xmm1\n" \
      "paddq  %%xmm5,%%xmm1\n" \
      "paddq  %%xmm5,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm5\n" \

      "movaps 32(%2),%%xmm1\n" \
      "movaps 32(%1),%%xmm6\n" \
      "movaps %%xmm6,32(%2)\n" \
      "psllq  $3,%%xmm6\n" \
      "paddq  %%xmm0,%%xmm6\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm6\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm6\n" \
      "movaps %%xmm6,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm6\n" \
      "paddq  %%xmm3,%%xmm6\n" \
      "movaps %%xmm6,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm6\n" \
      "movaps %%xmm6,32(%1)\n" \
      "movaps %%xmm6,%%xmm1\n" \
      "paddq  %%xmm6,%%xmm1\n" \
      "paddq  %%xmm6,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm6\n" \

      "movaps 48(%2),%%xmm1\n" \
      "movaps 48(%1),%%xmm7\n" \
      "movaps %%xmm7,48(%2)\n" \
      "psllq  $3,%%xmm7\n" \
      "paddq  %%xmm0,%%xmm7\n" \
      "psllq  $4,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm7\n" \
      "psllq  $1,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm7\n" \
      "movaps %%xmm7,%%xmm1\n" \
      "psrlq  $58,%%xmm1\n" \
      "psllq  $29,%%xmm1\n" \
      "movaps %%xmm1,%%xmm3\n" \
      "psllq  $1,%%xmm3\n" \
      "paddq  %%xmm1,%%xmm3\n" \
      "psllq  $29,%%xmm1\n" \
      "psubq  %%xmm1,%%xmm7\n" \
      "paddq  %%xmm3,%%xmm7\n" \
      "movaps %%xmm7,%%xmm1\n" \
      "paddq  16(%3),%%xmm1\n" \
      "pshufd $245,%%xmm1,%%xmm3\n" \
      "pcmpgtd 32(%3),%%xmm3\n" \
      "pand    48(%3),%%xmm3\n" \
      "psubq   %%xmm3,%%xmm7\n" \
      "movaps %%xmm7,48(%1)\n" \
      "movaps %%xmm7,%%xmm1\n" \
      "paddq  %%xmm7,%%xmm1\n" \
      "paddq  %%xmm7,%%xmm1\n" \
      "psrlq  $29,%%xmm1\n" \
      "paddq  %%xmm1,%%xmm7\n" \

      "psrlq  $54,%%xmm4\n" \
      "psrlq  $54,%%xmm5\n" \
      "psrlq  $54,%%xmm6\n" \
      "psrlq  $54,%%xmm7\n" \
      "packssdw  %%xmm5,%%xmm4\n" \
      "packssdw  %%xmm7,%%xmm6\n" \
      "packssdw  %%xmm6,%%xmm4\n" \
      "packsswb  %%xmm4,%%xmm4\n" \
      "movaps  %%xmm4,%%xmm0\n" \
      "psrldq   $4,%%xmm0\n" \
      "pslld    $4,%%xmm0\n" \
      "pxor    %%xmm0,%%xmm4\n"
      "movd    %%xmm4,%0\n" \
      "":"=&r"(output):"r"(state->xN),"r"(state->xP),"r"(gq58x4_sse_Consts));
      return output;
}

__device__ __host__ void gq58x4_get_sse_state_(gq58x4_state* state,gq58x4_sse_state* sse_state){
  int i; for(i=0;i<8;i++) {sse_state->xN[i]=state->xN[i]; sse_state->xP[i]=state->xP[i];}
}


__device__ __host__ lt gq58x4_mod_g(lt x){ // returns x (mod g)
  lt F,G; F = (x>>58); G = x-(F<<58)+(F<<29)+(F<<30);
  return ((G>=gq58x4_g) ? (G-gq58x4_g) : G);
}

__device__ __host__ lt gq58x4_MyMult(lt A,lt B){ // returns AB (mod gq58x4_g), where it is implied that A,B<gq58x4_g;
  lt A1,A0,B1,B0,curr,x,m;
  A1=A>>32; B1=B>>32; A0=A-(A1<<32)+(12*A1); B0=B-(B1<<32)+(12*B1);
  if(A0>>32) {A0-=4294967284ULL; A1++;}
  if(B0>>32) {B0-=4294967284ULL; B1++;}
  curr=A1*B0+B1*A0; m=curr>>26; x=curr-(m<<26);
  curr=((3*m+(x<<4))<<28)+(gq58x4_g-12*x)+(144*A1*B1)+(gq58x4_mod_g(A0*B0));
  return gq58x4_mod_g(curr);
}

__device__ __host__ lt gq58x4_CNext2(lt N,lt P,lt myk,lt myq){   // returns (myk*N-myq*P) (mod gq58x4_g)
  lt curr1,curr2;
  curr1=gq58x4_MyMult(myk,N); curr2=gq58x4_MyMult(myq,P);
  if(curr1>=curr2) return (curr1-curr2); else return (gq58x4_g+curr1-curr2);
}

__device__ __host__ lt gq58x4_CNext(lt N,lt P){ // returns (8N-48P) (mod gq58x4_g)
  return gq58x4_mod_g((N+6*(gq58x4_g-P))<<3);
}


__device__ __host__ lt gq58x4_GetNextN(lt x0,lt x1,unsigned int n){ //returns x_{2^n}
  lt myk=gq58x4_k,myq=gq58x4_q,i,x=x1;
  for(i=0;i<n;i++){
    x=gq58x4_CNext2(x,x0,myk,myq);
    myk=gq58x4_CNext2(myk,2,myk,myq);
    myq=gq58x4_CNext2(myq,0,myq,0);
  }
  return x;
}

__device__ __host__ lt gq58x4_GetNextAny(lt x0,lt x1,lt N64,lt N0){ //N=2^64*N64+N0+1
  lt i,xp=x0,xn=x1,xpnew,xnnew,shift=0;
  i=N0; while(i>0){
    if(i%2==1){                        // xp,xn ----> 2^shift
      xpnew=gq58x4_GetNextN(xp,xn,shift);
      xnnew=gq58x4_GetNextN(xn,gq58x4_CNext(xn,xp),shift);
      xp=xpnew; xn=xnnew;
    }
    i/=2; shift++;
  }
  i=N64; shift=64; while(i>0){
    if(i%2==1){                        // xp,xn ----> 2^shift
      xpnew=gq58x4_GetNextN(xp,xn,shift);
      xnnew=gq58x4_GetNextN(xn,gq58x4_CNext(xn,xp),shift);
      xp=xpnew; xn=xnnew;
    }
    i/=2; shift++;
  }
  return xp;                       // returns x_N, where N=2^64*N64+N0+1
}

__device__ __host__ void gq58x4_skipahead_(gq58x4_state* state, lt offset64, lt offset0){ // offset=offset64*2^64+offset0+1
  lt xn,xp,j; 
  for(j=0;j<8;j++){
    xp=gq58x4_GetNextAny(state->xP[j],state->xN[j],offset64,offset0);
    xn=gq58x4_GetNextAny(state->xP[j],state->xN[j],offset64,offset0+1);
    state->xP[j]=xp; state->xN[j]=xn;
  }
}

__device__ __host__ void gq58x4_init_(gq58x4_state* state){
  lt x0=100152853817629549ULL,x1=132388305121829306ULL,xp,xn,j;
  for(j=0;j<8;j++){
    xp=gq58x4_GetNextAny(x0,x1,0,35048736516210783ULL);
    xn=gq58x4_GetNextAny(x0,x1,0,35048736516210784ULL);
    state->xP[j]=xp; state->xN[j]=xn; x0=xp; x1=xn;
  }
}

__device__ __host__ void gq58x4_init_short_sequence_(gq58x4_state* state,unsigned SequenceNumber){
  gq58x4_init_(state);                     // 0 <= SequenceNumber < 3*10^8;   length of each sequence <= 8*10^7
  gq58x4_skipahead_(state,0,82927047ULL*(unsigned long long)SequenceNumber);
}

__device__ __host__ void gq58x4_init_medium_sequence_(gq58x4_state* state,unsigned SequenceNumber){
  gq58x4_init_(state);                     // 0 <= SequenceNumber < 3*10^6;   length of each sequence <= 8*10^9
  gq58x4_skipahead_(state,0,8799201913ULL*(unsigned long long)SequenceNumber);
}

__device__ __host__ void gq58x4_init_long_sequence_(gq58x4_state* state,unsigned SequenceNumber){
  gq58x4_init_(state);                     // 0 <= SequenceNumber < 3*10^4;   length of each sequence <= 8*10^11
  gq58x4_skipahead_(state,0,828317697521ULL*(unsigned long long)SequenceNumber);
}

__device__ __host__ unsigned int gq58x4_generate_(gq58x4_state* state){
  unsigned int sum=0; int i; lt temp;
  for(i=0;i<8;i++){ 
    temp=gq58x4_mod_g((state->xN[i]+6*(gq58x4_g-state->xP[i]))<<3);
    state->xP[i]=state->xN[i]; state->xN[i]=temp;
    sum+= ((temp/gq58x4_gdiv16)<<((i<4)?(8*i):(8*i-28)));
  }
  return sum;
}

__device__ __host__ float gq58x4_generate_uniform_float_(gq58x4_state* state){
  unsigned int sum=0; int i; lt temp;
  for(i=0;i<8;i++){ 
    temp=gq58x4_mod_g((state->xN[i]+6*(gq58x4_g-state->xP[i]))<<3);
    state->xP[i]=state->xN[i]; state->xN[i]=temp;
    sum+= ((temp/gq58x4_gdiv16)<<((i<4)?(8*i):(8*i-28)));
  }
  return ((float) sum) * 2.3283064365386963e-10;
}

__host__ void gq58x4_print_state_(gq58x4_state* state){int i;
    printf("Generator State:\nxN={");
    for(i=0;i<8;i++) {printf("%llu",state->xN[i]%gq58x4_g); printf((i<7)?",":"}\nxP={");}
    for(i=0;i<8;i++) {printf("%llu",state->xP[i]%gq58x4_g); printf((i<7)?",":"}\n\n");}
}

__host__ void gq58x4_print_sse_state_(gq58x4_sse_state* state){int i;
    printf("Generator State:\nxN={");
    for(i=0;i<8;i++) {printf("%llu",state->xN[i]%gq58x4_g); printf((i<7)?",":"}\nxP={");}
    for(i=0;i<8;i++) {printf("%llu",state->xP[i]%gq58x4_g); printf((i<7)?",":"}\n\n");}
}

__global__ void gq58x4_kernel_generate_array(gq58x4_state* state, unsigned int* out, long* length) {
    unsigned sum,i,j,orbit,seqNum,shift; long offset; lt temp;

    __shared__ lt xP[gq58x4_THREADS];        // one generator per s=8 threads, i.e. one orbit
    __shared__ lt xN[gq58x4_THREADS];        // per thread, i.e. blockDim.x orbits per block
    __shared__ unsigned  a[gq58x4_THREADS];  // array "a" contains corresponding parts of output

    orbit   = threadIdx.x % 8;
    seqNum  = (threadIdx.x + blockIdx.x * blockDim.x)>>3;  // RNG_sequence index
    offset  = seqNum*(*length);                            // start of the section in the output array

    xP[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset);
    xN[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset+1);

    shift=((orbit<4)?(8*orbit):(8*orbit-28));

    for(i=0;i<(*length);i++){

      temp = gq58x4_CNext( xN[threadIdx.x], xP[threadIdx.x] );
      xP[threadIdx.x] = xN[threadIdx.x]; xN[threadIdx.x] = temp; 
      a[threadIdx.x]  = ((temp/gq58x4_gdiv16)<<shift);

      __syncthreads();              // each s=8 threads result in "length" values in the output array

      if(orbit==0){ sum=0; for(j=0;j<8;j++) sum+=a[threadIdx.x+j]; out[offset+i]=sum; }

    }
}

__host__ void gq58x4_generate_gpu_array_(gq58x4_state* state, unsigned int* dev_out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(hipMemcpy(dev_state,state,sizeof(gq58x4_state),hipMemcpyHostToDevice));
   gq58x4_CUDA_CALL(hipMemcpy(dev_length,&mylength,sizeof(long),hipMemcpyHostToDevice));

   gq58x4_kernel_generate_array<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(hipGetLastError());
   
   gq58x4_CUDA_CALL(hipFree(dev_state)); gq58x4_CUDA_CALL(hipFree(dev_length));

}

__global__ void gq58x4_kernel_generate_array_float(gq58x4_state* state, float* out, long* length) {
    unsigned sum,i,j,orbit,seqNum,shift; long offset; lt temp;

    __shared__ lt xP[gq58x4_THREADS];        // one generator per s=8 threads, i.e. one orbit
    __shared__ lt xN[gq58x4_THREADS];        // per thread, i.e. blockDim.x orbits per block
    __shared__ unsigned  a[gq58x4_THREADS];  // array "a" contains corresponding parts of output

    orbit   = threadIdx.x % 8;
    seqNum  = (threadIdx.x + blockIdx.x * blockDim.x)>>3;  // RNG_sequence index
    offset  = seqNum*(*length);                            // start of the section in the output array

    xP[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset);
    xN[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset+1);

    shift=((orbit<4)?(8*orbit):(8*orbit-28));

    for(i=0;i<(*length);i++){

      temp = gq58x4_CNext( xN[threadIdx.x], xP[threadIdx.x] );
      xP[threadIdx.x] = xN[threadIdx.x]; xN[threadIdx.x] = temp; 
      a[threadIdx.x]  = ((temp/gq58x4_gdiv16)<<shift);

      __syncthreads();              // each s=8 threads result in "length" values in the output array

      if(orbit==0){ sum=0; for(j=0;j<8;j++) sum+=a[threadIdx.x+j]; out[offset+i]=((float)sum)* 2.3283064365386963e-10; }

    }
}

__host__ void gq58x4_generate_gpu_array_float_(gq58x4_state* state, float* dev_out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(hipMemcpy(dev_state,state,sizeof(gq58x4_state),hipMemcpyHostToDevice));
   gq58x4_CUDA_CALL(hipMemcpy(dev_length,&mylength,sizeof(long),hipMemcpyHostToDevice));

   gq58x4_kernel_generate_array_float<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(hipGetLastError());
   
   gq58x4_CUDA_CALL(hipFree(dev_state)); gq58x4_CUDA_CALL(hipFree(dev_length));

}

__global__ void gq58x4_kernel_generate_array_double(gq58x4_state* state, double* out, long* length) {
    unsigned sum,i,j,orbit,seqNum,shift; long offset; lt temp;

    __shared__ lt xP[gq58x4_THREADS];        // one generator per s=8 threads, i.e. one orbit
    __shared__ lt xN[gq58x4_THREADS];        // per thread, i.e. blockDim.x orbits per block
    __shared__ unsigned  a[gq58x4_THREADS];  // array "a" contains corresponding parts of output

    orbit   = threadIdx.x % 8;
    seqNum  = (threadIdx.x + blockIdx.x * blockDim.x)>>3;  // RNG_sequence index
    offset  = seqNum*(*length);                            // start of the section in the output array

    xP[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset);
    xN[threadIdx.x]=gq58x4_GetNextAny(state->xP[orbit],state->xN[orbit],0,offset+1);

    shift=((orbit<4)?(8*orbit):(8*orbit-28));

    for(i=0;i<(*length);i++){

      temp = gq58x4_CNext( xN[threadIdx.x], xP[threadIdx.x] );
      xP[threadIdx.x] = xN[threadIdx.x]; xN[threadIdx.x] = temp; 
      a[threadIdx.x]  = ((temp/gq58x4_gdiv16)<<shift);

      __syncthreads();              // each s=8 threads result in "length" values in the output array

      if(orbit==0){ sum=0; for(j=0;j<8;j++) sum+=a[threadIdx.x+j]; out[offset+i]=((double)sum)* 2.3283064365386963e-10; }

    }
}

__host__ void gq58x4_generate_gpu_array_double_(gq58x4_state* state, double* dev_out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(hipMemcpy(dev_state,state,sizeof(gq58x4_state),hipMemcpyHostToDevice));
   gq58x4_CUDA_CALL(hipMemcpy(dev_length,&mylength,sizeof(long),hipMemcpyHostToDevice));

   gq58x4_kernel_generate_array_double<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(hipGetLastError());
   
   gq58x4_CUDA_CALL(hipFree(dev_state)); gq58x4_CUDA_CALL(hipFree(dev_length));

}

__host__ void gq58x4_generate_array_(gq58x4_state* state, unsigned int* out, long length){

   long          mylength = length/gq58x4_ARRAY_SECTIONS;
   gq58x4_state*   dev_state;
   unsigned int* dev_out;
   long*         dev_length;

   if((mylength*gq58x4_ARRAY_SECTIONS)<length) mylength++;

   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_state,sizeof(gq58x4_state)));
   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_out,mylength*gq58x4_ARRAY_SECTIONS*sizeof(unsigned int)));
   gq58x4_CUDA_CALL(hipMalloc((void**)&dev_length,sizeof(long)));
   gq58x4_CUDA_CALL(hipMemcpy(dev_state,state,sizeof(gq58x4_state),hipMemcpyHostToDevice));
   gq58x4_CUDA_CALL(hipMemcpy(dev_length,&mylength,sizeof(long),hipMemcpyHostToDevice));

   gq58x4_kernel_generate_array<<<gq58x4_BLOCKS,gq58x4_THREADS>>>(dev_state,dev_out,dev_length);
   gq58x4_CUDA_CALL(hipGetLastError());
   
   gq58x4_CUDA_CALL(hipMemcpy(out,dev_out,length*sizeof(unsigned int),hipMemcpyDeviceToHost));
   gq58x4_CUDA_CALL(hipFree(dev_state)); gq58x4_CUDA_CALL(hipFree(dev_out)); 
   gq58x4_CUDA_CALL(hipFree(dev_length));

}

	.text
	.file	"_gq58x4.hip"
	.globl	_Z20gq58x4_sse_generate_P12gq58x4_state # -- Begin function _Z20gq58x4_sse_generate_P12gq58x4_state
	.type	_Z20gq58x4_sse_generate_P12gq58x4_state,@function
_Z20gq58x4_sse_generate_P12gq58x4_state: # @_Z20gq58x4_sse_generate_P12gq58x4_state
	.cfi_startproc
# %bb.0:
	leaq	64(%rdi), %rcx
	movl	$gq58x4_sse_Consts, %edx
	#APP
	movaps	(%rdx), %xmm0
	movaps	(%rcx), %xmm1
	movaps	(%rdi), %xmm4
	movaps	%xmm4, (%rcx)
	psllq	$3, %xmm4
	paddq	%xmm0, %xmm4
	psllq	$4, %xmm1
	psubq	%xmm1, %xmm4
	psllq	$1, %xmm1
	psubq	%xmm1, %xmm4
	movaps	%xmm4, %xmm1
	psrlq	$58, %xmm1
	psllq	$29, %xmm1
	movaps	%xmm1, %xmm3
	psllq	$1, %xmm3
	paddq	%xmm1, %xmm3
	psllq	$29, %xmm1
	psubq	%xmm1, %xmm4
	paddq	%xmm3, %xmm4
	movaps	%xmm4, %xmm1
	paddq	16(%rdx), %xmm1
	pshufd	$245, %xmm1, %xmm3              # xmm3 = xmm1[1,1,3,3]
	pcmpgtd	32(%rdx), %xmm3
	pand	48(%rdx), %xmm3
	psubq	%xmm3, %xmm4
	movaps	%xmm4, (%rdi)
	movaps	%xmm4, %xmm1
	paddq	%xmm4, %xmm1
	paddq	%xmm4, %xmm1
	psrlq	$29, %xmm1
	paddq	%xmm1, %xmm4
	movaps	16(%rcx), %xmm1
	movaps	16(%rdi), %xmm5
	movaps	%xmm5, 16(%rcx)
	psllq	$3, %xmm5
	paddq	%xmm0, %xmm5
	psllq	$4, %xmm1
	psubq	%xmm1, %xmm5
	psllq	$1, %xmm1
	psubq	%xmm1, %xmm5
	movaps	%xmm5, %xmm1
	psrlq	$58, %xmm1
	psllq	$29, %xmm1
	movaps	%xmm1, %xmm3
	psllq	$1, %xmm3
	paddq	%xmm1, %xmm3
	psllq	$29, %xmm1
	psubq	%xmm1, %xmm5
	paddq	%xmm3, %xmm5
	movaps	%xmm5, %xmm1
	paddq	16(%rdx), %xmm1
	pshufd	$245, %xmm1, %xmm3              # xmm3 = xmm1[1,1,3,3]
	pcmpgtd	32(%rdx), %xmm3
	pand	48(%rdx), %xmm3
	psubq	%xmm3, %xmm5
	movaps	%xmm5, 16(%rdi)
	movaps	%xmm5, %xmm1
	paddq	%xmm5, %xmm1
	paddq	%xmm5, %xmm1
	psrlq	$29, %xmm1
	paddq	%xmm1, %xmm5
	movaps	32(%rcx), %xmm1
	movaps	32(%rdi), %xmm6
	movaps	%xmm6, 32(%rcx)
	psllq	$3, %xmm6
	paddq	%xmm0, %xmm6
	psllq	$4, %xmm1
	psubq	%xmm1, %xmm6
	psllq	$1, %xmm1
	psubq	%xmm1, %xmm6
	movaps	%xmm6, %xmm1
	psrlq	$58, %xmm1
	psllq	$29, %xmm1
	movaps	%xmm1, %xmm3
	psllq	$1, %xmm3
	paddq	%xmm1, %xmm3
	psllq	$29, %xmm1
	psubq	%xmm1, %xmm6
	paddq	%xmm3, %xmm6
	movaps	%xmm6, %xmm1
	paddq	16(%rdx), %xmm1
	pshufd	$245, %xmm1, %xmm3              # xmm3 = xmm1[1,1,3,3]
	pcmpgtd	32(%rdx), %xmm3
	pand	48(%rdx), %xmm3
	psubq	%xmm3, %xmm6
	movaps	%xmm6, 32(%rdi)
	movaps	%xmm6, %xmm1
	paddq	%xmm6, %xmm1
	paddq	%xmm6, %xmm1
	psrlq	$29, %xmm1
	paddq	%xmm1, %xmm6
	movaps	48(%rcx), %xmm1
	movaps	48(%rdi), %xmm7
	movaps	%xmm7, 48(%rcx)
	psllq	$3, %xmm7
	paddq	%xmm0, %xmm7
	psllq	$4, %xmm1
	psubq	%xmm1, %xmm7
	psllq	$1, %xmm1
	psubq	%xmm1, %xmm7
	movaps	%xmm7, %xmm1
	psrlq	$58, %xmm1
	psllq	$29, %xmm1
	movaps	%xmm1, %xmm3
	psllq	$1, %xmm3
	paddq	%xmm1, %xmm3
	psllq	$29, %xmm1
	psubq	%xmm1, %xmm7
	paddq	%xmm3, %xmm7
	movaps	%xmm7, %xmm1
	paddq	16(%rdx), %xmm1
	pshufd	$245, %xmm1, %xmm3              # xmm3 = xmm1[1,1,3,3]
	pcmpgtd	32(%rdx), %xmm3
	pand	48(%rdx), %xmm3
	psubq	%xmm3, %xmm7
	movaps	%xmm7, 48(%rdi)
	movaps	%xmm7, %xmm1
	paddq	%xmm7, %xmm1
	paddq	%xmm7, %xmm1
	psrlq	$29, %xmm1
	paddq	%xmm1, %xmm7
	psrlq	$54, %xmm4
	psrlq	$54, %xmm5
	psrlq	$54, %xmm6
	psrlq	$54, %xmm7
	packssdw	%xmm5, %xmm4
	packssdw	%xmm7, %xmm6
	packssdw	%xmm6, %xmm4
	packsswb	%xmm4, %xmm4
	movaps	%xmm4, %xmm0
	psrldq	$4, %xmm0                       # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
	pslld	$4, %xmm0
	pxor	%xmm0, %xmm4
	movd	%xmm4, %eax

	#NO_APP
	retq
.Lfunc_end0:
	.size	_Z20gq58x4_sse_generate_P12gq58x4_state, .Lfunc_end0-_Z20gq58x4_sse_generate_P12gq58x4_state
	.cfi_endproc
                                        # -- End function
	.globl	_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_ # -- Begin function _Z21gq58x4_get_sse_state_P12gq58x4_stateS0_
	.type	_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_,@function
_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_: # @_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_
	.cfi_startproc
# %bb.0:
	movq	$-8, %rax
.LBB1_1:                                # =>This Inner Loop Header: Depth=1
	movq	64(%rdi,%rax,8), %rcx
	movq	%rcx, 64(%rsi,%rax,8)
	movq	128(%rdi,%rax,8), %rcx
	movq	%rcx, 128(%rsi,%rax,8)
	incq	%rax
	jne	.LBB1_1
# %bb.2:
	retq
.Lfunc_end1:
	.size	_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_, .Lfunc_end1-_Z21gq58x4_get_sse_state_P12gq58x4_stateS0_
	.cfi_endproc
                                        # -- End function
	.globl	_Z12gq58x4_mod_gy               # -- Begin function _Z12gq58x4_mod_gy
	.type	_Z12gq58x4_mod_gy,@function
_Z12gq58x4_mod_gy:                      # @_Z12gq58x4_mod_gy
	.cfi_startproc
# %bb.0:
	movabsq	$288230374541099007, %rax       # imm = 0x3FFFFFF9FFFFFFF
	orq	$1610612736, %rax               # imm = 0x60000000
	andq	%rdi, %rax
	shrq	$58, %rdi
	movq	%rdi, %rcx
	shlq	$29, %rcx
	shlq	$30, %rdi
	addq	%rcx, %rdi
	addq	%rax, %rdi
	movq	%rdi, %rcx
	shrq	$29, %rcx
	movabsq	$-288230374541099008, %rax      # imm = 0xFC00000060000000
	addq	%rdi, %rax
	cmpl	$536870909, %ecx                # imm = 0x1FFFFFFD
	cmovbq	%rdi, %rax
	retq
.Lfunc_end2:
	.size	_Z12gq58x4_mod_gy, .Lfunc_end2-_Z12gq58x4_mod_gy
	.cfi_endproc
                                        # -- End function
	.globl	_Z13gq58x4_MyMultyy             # -- Begin function _Z13gq58x4_MyMultyy
	.type	_Z13gq58x4_MyMultyy,@function
_Z13gq58x4_MyMultyy:                    # @_Z13gq58x4_MyMultyy
	.cfi_startproc
# %bb.0:
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset %rbx, -16
	movl	%edi, %eax
	movq	%rdi, %rcx
	shrq	$32, %rcx
	movl	%esi, %edx
	movq	%rsi, %rdi
	shrq	$32, %rdi
	leaq	(%rcx,%rcx,2), %rsi
	leaq	(%rax,%rsi,4), %r8
	leaq	(%rdi,%rdi,2), %rax
	leaq	(%rdx,%rax,4), %r9
	movq	%r8, %r10
	shrq	$32, %r10
	movabsq	$-4294967284, %rax              # imm = 0xFFFFFFFF0000000C
	leaq	(%r8,%rax), %rdx
	xorl	%esi, %esi
	testq	%r10, %r10
	setne	%sil
	cmoveq	%r8, %rdx
	addq	%rcx, %rsi
	movq	%r9, %r8
	shrq	$32, %r8
	addq	%r9, %rax
	xorl	%ecx, %ecx
	testq	%r8, %r8
	setne	%cl
	cmoveq	%r9, %rax
	addq	%rdi, %rcx
	movq	%rsi, %rdi
	imulq	%rax, %rdi
	imulq	%rcx, %rsi
	imulq	%rdx, %rcx
	addq	%rdi, %rcx
	movq	%rcx, %rdi
	shrq	$26, %rdi
	andl	$67108863, %ecx                 # imm = 0x3FFFFFF
	leaq	(%rdi,%rdi,2), %rdi
	shlq	$28, %rdi
	leaq	(%rsi,%rsi,8), %rsi
	shlq	$4, %rsi
	imulq	%rdx, %rax
	movq	%rax, %r9
	shrq	$58, %r9
	movabsq	$288230374541099007, %r10       # imm = 0x3FFFFFF9FFFFFFF
	leaq	1610612736(%r10), %rdx
	andq	%rdx, %rax
	movq	%r9, %r8
	shlq	$29, %r8
	addq	%rax, %r8
	shlq	$30, %r9
	addq	%r8, %r9
	movq	%r9, %r11
	shrq	$29, %r11
	movabsq	$-288230374541099008, %rax      # imm = 0xFC00000060000000
	leaq	(%r9,%rax), %rbx
	movl	$536870909, %r8d                # imm = 0x1FFFFFFD
	cmpl	%r8d, %r11d
	cmovbq	%r9, %rbx
	movl	$4294967284, %r9d               # imm = 0xFFFFFFF4
	imulq	%rcx, %r9
	addq	%rdi, %rsi
	addq	%r9, %rsi
	addq	%rbx, %rsi
	leaq	(%r10,%rsi), %rcx
	incq	%rcx
	movq	%rcx, %rsi
	shrq	$58, %rsi
	andq	%rdx, %rcx
	movq	%rsi, %rdx
	shlq	$29, %rdx
	addq	%rcx, %rdx
	shlq	$30, %rsi
	addq	%rdx, %rsi
	movq	%rsi, %rcx
	shrq	$29, %rcx
	addq	%rsi, %rax
	cmpl	%r8d, %ecx
	cmovbq	%rsi, %rax
	popq	%rbx
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end3:
	.size	_Z13gq58x4_MyMultyy, .Lfunc_end3-_Z13gq58x4_MyMultyy
	.cfi_endproc
                                        # -- End function
	.globl	_Z13gq58x4_CNext2yyyy           # -- Begin function _Z13gq58x4_CNext2yyyy
	.type	_Z13gq58x4_CNext2yyyy,@function
_Z13gq58x4_CNext2yyyy:                  # @_Z13gq58x4_CNext2yyyy
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	movq	%rcx, %rbx
	movq	%rsi, %r14
	movq	%rdi, %rsi
	movq	%rdx, %rdi
	callq	_Z13gq58x4_MyMultyy
	movq	%rax, %r15
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_Z13gq58x4_MyMultyy
	movabsq	$288230374541099008, %rcx       # imm = 0x3FFFFFFA0000000
	addq	%r15, %rcx
	cmpq	%rax, %r15
	cmovaeq	%r15, %rcx
	subq	%rax, %rcx
	movq	%rcx, %rax
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end4:
	.size	_Z13gq58x4_CNext2yyyy, .Lfunc_end4-_Z13gq58x4_CNext2yyyy
	.cfi_endproc
                                        # -- End function
	.globl	_Z12gq58x4_CNextyy              # -- Begin function _Z12gq58x4_CNextyy
	.type	_Z12gq58x4_CNextyy,@function
_Z12gq58x4_CNextyy:                     # @_Z12gq58x4_CNextyy
	.cfi_startproc
# %bb.0:
	movabsq	$288230374541099007, %rax       # imm = 0x3FFFFFF9FFFFFFF
	movq	%rax, %rcx
	subq	%rsi, %rcx
	leaq	(%rcx,%rcx,2), %rcx
	leaq	(%rdi,%rcx,2), %rcx
	leaq	48(,%rcx,8), %rcx
	addq	$1610612729, %rax               # imm = 0x5FFFFFF9
	andq	%rcx, %rax
	shrq	$58, %rcx
	movq	%rcx, %rdx
	shlq	$29, %rdx
	addq	%rax, %rdx
	shlq	$30, %rcx
	addq	%rdx, %rcx
	movq	%rcx, %rdx
	shrq	$29, %rdx
	movabsq	$-288230374541099008, %rax      # imm = 0xFC00000060000000
	addq	%rcx, %rax
	cmpl	$536870909, %edx                # imm = 0x1FFFFFFD
	cmovbq	%rcx, %rax
	retq
.Lfunc_end5:
	.size	_Z12gq58x4_CNextyy, .Lfunc_end5-_Z12gq58x4_CNextyy
	.cfi_endproc
                                        # -- End function
	.globl	_Z15gq58x4_GetNextNyyj          # -- Begin function _Z15gq58x4_GetNextNyyj
	.type	_Z15gq58x4_GetNextNyyj,@function
_Z15gq58x4_GetNextNyyj:                 # @_Z15gq58x4_GetNextNyyj
	.cfi_startproc
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r15
	.cfi_def_cfa_offset 24
	pushq	%r14
	.cfi_def_cfa_offset 32
	pushq	%r13
	.cfi_def_cfa_offset 40
	pushq	%r12
	.cfi_def_cfa_offset 48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	pushq	%rax
	.cfi_def_cfa_offset 64
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	%rsi, %r14
	testl	%edx, %edx
	je	.LBB6_3
# %bb.1:                                # %.lr.ph.preheader
	movl	%edx, %ebp
	movl	$8, %r12d
	movl	$48, %r15d
	movq	%rdi, (%rsp)                    # 8-byte Spill
	movabsq	$288230374541099008, %rbx       # imm = 0x3FFFFFFA0000000
.LBB6_2:                                # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
	movq	%r12, %rdi
	movq	%r14, %rsi
	callq	_Z13gq58x4_MyMultyy
	movq	%rax, %r13
	movq	%r15, %rdi
	movq	(%rsp), %rsi                    # 8-byte Reload
	callq	_Z13gq58x4_MyMultyy
	leaq	(%rbx,%r13), %r14
	cmpq	%rax, %r13
	cmovaeq	%r13, %r14
	subq	%rax, %r14
	movq	%r12, %rdi
	movq	%r12, %rsi
	callq	_Z13gq58x4_MyMultyy
	movq	%rax, %r13
	movl	$2, %esi
	movq	%r15, %rdi
	callq	_Z13gq58x4_MyMultyy
	leaq	(%rbx,%r13), %r12
	cmpq	%rax, %r13
	cmovaeq	%r13, %r12
	subq	%rax, %r12
	movq	%r15, %rdi
	movq	%r15, %rsi
	callq	_Z13gq58x4_MyMultyy
	movq	%rax, %r15
	decq	%rbp
	jne	.LBB6_2
.LBB6_3:                                # %._crit_edge
	movq	%r14, %rax
	addq	$8, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%r12
	.cfi_def_cfa_offset 40
	popq	%r13
	.cfi_def_cfa_offset 32
	popq	%r14
	.cfi_def_cfa_offset 24
	popq	%r15
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end6:
	.size	_Z15gq58x4_GetNextNyyj, .Lfunc_end6-_Z15gq58x4_GetNextNyyj
	.cfi_endproc
                                        # -- End function
	.globl	_Z17gq58x4_GetNextAnyyyyy       # -- Begin function _Z17gq58x4_GetNextAnyyyyy
	.type	_Z17gq58x4_GetNextAnyyyyy,@function
_Z17gq58x4_GetNextAnyyyyy:              # @_Z17gq58x4_GetNextAnyyyyy
	.cfi_startproc
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r15
	.cfi_def_cfa_offset 24
	pushq	%r14
	.cfi_def_cfa_offset 32
	pushq	%r13
	.cfi_def_cfa_offset 40
	pushq	%r12
	.cfi_def_cfa_offset 48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	pushq	%rax
	.cfi_def_cfa_offset 64
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	%rdx, %rbx
	movq	%rsi, %r14
	movq	%rdi, %r15
	movabsq	$288230374541099007, %rax       # imm = 0x3FFFFFF9FFFFFFF
	testq	%rcx, %rcx
	je	.LBB7_5
# %bb.1:                                # %.lr.ph.preheader
	movq	%rcx, %r12
	xorl	%ebp, %ebp
	addq	$1610612729, %rax               # imm = 0x5FFFFFF9
	movq	%rax, (%rsp)                    # 8-byte Spill
.LBB7_2:                                # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
	testb	$1, %r12b
	je	.LBB7_4
# %bb.3:                                #   in Loop: Header=BB7_2 Depth=1
	movq	%r15, %rdi
	movq	%r14, %rsi
	movl	%ebp, %edx
	callq	_Z15gq58x4_GetNextNyyj
	movq	%rax, %r13
	movabsq	$288230374541099007, %rdi       # imm = 0x3FFFFFF9FFFFFFF
	movq	%rdi, %rax
	subq	%r15, %rax
	leaq	(%rax,%rax,2), %rax
	leaq	(%r14,%rax,2), %rax
	leaq	48(,%rax,8), %rax
	movq	%rax, %rcx
	shrq	$58, %rcx
	andq	(%rsp), %rax                    # 8-byte Folded Reload
	movq	%rcx, %rdx
	shlq	$29, %rdx
	addq	%rax, %rdx
	shlq	$30, %rcx
	addq	%rdx, %rcx
	movabsq	$-288230374541099008, %rax      # imm = 0xFC00000060000000
	leaq	(%rcx,%rax), %rsi
	cmpq	%rdi, %rcx
	cmovbeq	%rcx, %rsi
	movq	%r14, %rdi
	movl	%ebp, %edx
	callq	_Z15gq58x4_GetNextNyyj
	movq	%rax, %r14
	movq	%r13, %r15
.LBB7_4:                                #   in Loop: Header=BB7_2 Depth=1
	movq	%r12, %rax
	shrq	%rax
	incl	%ebp
	cmpq	$2, %r12
	movq	%rax, %r12
	jae	.LBB7_2
.LBB7_5:                                # %.preheader
	testq	%rbx, %rbx
	je	.LBB7_10
# %bb.6:                                # %.lr.ph53.preheader
	movl	$64, %ebp
	movabsq	$288230374541099007, %rax       # imm = 0x3FFFFFF9FFFFFFF
	leaq	1610612729(%rax), %r13
.LBB7_7:                                # %.lr.ph53
                                        # =>This Inner Loop Header: Depth=1
	testb	$1, %bl
	je	.LBB7_9
# %bb.8:                                #   in Loop: Header=BB7_7 Depth=1
	movq	%r15, %rdi
	movq	%r14, %rsi
	movl	%ebp, %edx
	callq	_Z15gq58x4_GetNextNyyj
	movq	%rax, %r12
	movabsq	$288230374541099007, %rdi       # imm = 0x3FFFFFF9FFFFFFF
	movq	%rdi, %rax
	subq	%r15, %rax
	leaq	(%rax,%rax,2), %rax
	leaq	(%r14,%rax,2), %rax
	leaq	48(,%rax,8), %rax
	movq	%rax, %rcx
	shrq	$58, %rcx
	andq	%r13, %rax
	movq	%rcx, %rdx
	shlq	$29, %rdx
	addq	%rax, %rdx
	shlq	$30, %rcx
	addq	%rdx, %rcx
	movabsq	$-288230374541099008, %rax      # imm = 0xFC00000060000000
	leaq	(%rcx,%rax), %rsi
	cmpq	%rdi, %rcx
	cmovbeq	%rcx, %rsi
	movq	%r14, %rdi
	movl	%ebp, %edx
	callq	_Z15gq58x4_GetNextNyyj
	movq	%rax, %r14
	movq	%r12, %r15
.LBB7_9:                                #   in Loop: Header=BB7_7 Depth=1
	movq	%rbx, %rax
	shrq	%rax
	incl	%ebp
	cmpq	$1, %rbx
	movq	%rax, %rbx
	ja	.LBB7_7
.LBB7_10:                               # %._crit_edge
	movq	%r15, %rax
	addq	$8, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%r12
	.cfi_def_cfa_offset 40
	popq	%r13
	.cfi_def_cfa_offset 32
	popq	%r14
	.cfi_def_cfa_offset 24
	popq	%r15
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end7:
	.size	_Z17gq58x4_GetNextAnyyyyy, .Lfunc_end7-_Z17gq58x4_GetNextAnyyyyy
	.cfi_endproc
                                        # -- End function
	.globl	_Z17gq58x4_skipahead_P12gq58x4_stateyy # -- Begin function _Z17gq58x4_skipahead_P12gq58x4_stateyy
	.type	_Z17gq58x4_skipahead_P12gq58x4_stateyy,@function
_Z17gq58x4_skipahead_P12gq58x4_stateyy: # @_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.cfi_startproc
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r15
	.cfi_def_cfa_offset 24
	pushq	%r14
	.cfi_def_cfa_offset 32
	pushq	%r13
	.cfi_def_cfa_offset 40
	pushq	%r12
	.cfi_def_cfa_offset 48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	subq	$24, %rsp
	.cfi_def_cfa_offset 80
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	%rsi, %r14
	movq	%rdi, %r15
	movq	%rdx, 16(%rsp)                  # 8-byte Spill
	leaq	1(%rdx), %rax
	movq	%rax, 8(%rsp)                   # 8-byte Spill
	movq	$-64, %r12
.LBB8_1:                                # =>This Inner Loop Header: Depth=1
	movq	64(%r15,%r12), %r13
	movq	128(%r15,%r12), %rbp
	movq	%rbp, %rdi
	movq	%r13, %rsi
	movq	%r14, %rdx
	movq	16(%rsp), %rcx                  # 8-byte Reload
	callq	_Z17gq58x4_GetNextAnyyyyy
	movq	%rax, %rbx
	movq	%rbp, %rdi
	movq	%r13, %rsi
	movq	%r14, %rdx
	movq	8(%rsp), %rcx                   # 8-byte Reload
	callq	_Z17gq58x4_GetNextAnyyyyy
	movq	%rbx, 128(%r15,%r12)
	movq	%rax, 64(%r15,%r12)
	addq	$8, %r12
	jne	.LBB8_1
# %bb.2:
	addq	$24, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%r12
	.cfi_def_cfa_offset 40
	popq	%r13
	.cfi_def_cfa_offset 32
	popq	%r14
	.cfi_def_cfa_offset 24
	popq	%r15
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end8:
	.size	_Z17gq58x4_skipahead_P12gq58x4_stateyy, .Lfunc_end8-_Z17gq58x4_skipahead_P12gq58x4_stateyy
	.cfi_endproc
                                        # -- End function
	.globl	_Z12gq58x4_init_P12gq58x4_state # -- Begin function _Z12gq58x4_init_P12gq58x4_state
	.type	_Z12gq58x4_init_P12gq58x4_state,@function
_Z12gq58x4_init_P12gq58x4_state:        # @_Z12gq58x4_init_P12gq58x4_state
	.cfi_startproc
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r15
	.cfi_def_cfa_offset 24
	pushq	%r14
	.cfi_def_cfa_offset 32
	pushq	%r13
	.cfi_def_cfa_offset 40
	pushq	%r12
	.cfi_def_cfa_offset 48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	pushq	%rax
	.cfi_def_cfa_offset 64
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	%rdi, %rbx
	movabsq	$132388305121829306, %r15       # imm = 0x1D656764B33E1BA
	movabsq	$100152853817629549, %r13       # imm = 0x163D07D6B0A9B6D
	movq	$-64, %r14
	movabsq	$35048736516210783, %rax        # imm = 0x7C84A3E1E0005F
	leaq	1(%rax), %r12
.LBB9_1:                                # =>This Inner Loop Header: Depth=1
	movq	%r13, %rdi
	movq	%r15, %rsi
	xorl	%edx, %edx
	movabsq	$35048736516210783, %rcx        # imm = 0x7C84A3E1E0005F
	callq	_Z17gq58x4_GetNextAnyyyyy
	movq	%rax, %rbp
	movq	%r13, %rdi
	movq	%r15, %rsi
	xorl	%edx, %edx
	movq	%r12, %rcx
	callq	_Z17gq58x4_GetNextAnyyyyy
	movq	%rax, %r15
	movq	%rbp, 128(%rbx,%r14)
	movq	%rax, 64(%rbx,%r14)
	movq	%rbp, %r13
	addq	$8, %r14
	jne	.LBB9_1
# %bb.2:
	addq	$8, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%r12
	.cfi_def_cfa_offset 40
	popq	%r13
	.cfi_def_cfa_offset 32
	popq	%r14
	.cfi_def_cfa_offset 24
	popq	%r15
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end9:
	.size	_Z12gq58x4_init_P12gq58x4_state, .Lfunc_end9-_Z12gq58x4_init_P12gq58x4_state
	.cfi_endproc
                                        # -- End function
	.globl	_Z27gq58x4_init_short_sequence_P12gq58x4_statej # -- Begin function _Z27gq58x4_init_short_sequence_P12gq58x4_statej
	.type	_Z27gq58x4_init_short_sequence_P12gq58x4_statej,@function
_Z27gq58x4_init_short_sequence_P12gq58x4_statej: # @_Z27gq58x4_init_short_sequence_P12gq58x4_statej
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	pushq	%rax
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movl	%esi, %ebx
	movq	%rdi, %r14
	callq	_Z12gq58x4_init_P12gq58x4_state
	movl	%ebx, %eax
	imulq	$82927047, %rax, %rdx           # imm = 0x4F15DC7
	movq	%r14, %rdi
	xorl	%esi, %esi
	addq	$8, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	jmp	_Z17gq58x4_skipahead_P12gq58x4_stateyy # TAILCALL
.Lfunc_end10:
	.size	_Z27gq58x4_init_short_sequence_P12gq58x4_statej, .Lfunc_end10-_Z27gq58x4_init_short_sequence_P12gq58x4_statej
	.cfi_endproc
                                        # -- End function
	.globl	_Z28gq58x4_init_medium_sequence_P12gq58x4_statej # -- Begin function _Z28gq58x4_init_medium_sequence_P12gq58x4_statej
	.type	_Z28gq58x4_init_medium_sequence_P12gq58x4_statej,@function
_Z28gq58x4_init_medium_sequence_P12gq58x4_statej: # @_Z28gq58x4_init_medium_sequence_P12gq58x4_statej
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	pushq	%rax
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movl	%esi, %ebx
	movq	%rdi, %r14
	callq	_Z12gq58x4_init_P12gq58x4_state
	movl	%ebx, %eax
	movabsq	$8799201913, %rdx               # imm = 0x20C792A79
	imulq	%rax, %rdx
	movq	%r14, %rdi
	xorl	%esi, %esi
	addq	$8, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	jmp	_Z17gq58x4_skipahead_P12gq58x4_stateyy # TAILCALL
.Lfunc_end11:
	.size	_Z28gq58x4_init_medium_sequence_P12gq58x4_statej, .Lfunc_end11-_Z28gq58x4_init_medium_sequence_P12gq58x4_statej
	.cfi_endproc
                                        # -- End function
	.globl	_Z26gq58x4_init_long_sequence_P12gq58x4_statej # -- Begin function _Z26gq58x4_init_long_sequence_P12gq58x4_statej
	.type	_Z26gq58x4_init_long_sequence_P12gq58x4_statej,@function
_Z26gq58x4_init_long_sequence_P12gq58x4_statej: # @_Z26gq58x4_init_long_sequence_P12gq58x4_statej
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	pushq	%rax
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movl	%esi, %ebx
	movq	%rdi, %r14
	callq	_Z12gq58x4_init_P12gq58x4_state
	movl	%ebx, %eax
	movabsq	$828317697521, %rdx             # imm = 0xC0DB9505F1
	imulq	%rax, %rdx
	movq	%r14, %rdi
	xorl	%esi, %esi
	addq	$8, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	jmp	_Z17gq58x4_skipahead_P12gq58x4_stateyy # TAILCALL
.Lfunc_end12:
	.size	_Z26gq58x4_init_long_sequence_P12gq58x4_statej, .Lfunc_end12-_Z26gq58x4_init_long_sequence_P12gq58x4_statej
	.cfi_endproc
                                        # -- End function
	.globl	_Z16gq58x4_generate_P12gq58x4_state # -- Begin function _Z16gq58x4_generate_P12gq58x4_state
	.type	_Z16gq58x4_generate_P12gq58x4_state,@function
_Z16gq58x4_generate_P12gq58x4_state:    # @_Z16gq58x4_generate_P12gq58x4_state
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	xorl	%r8d, %r8d
	movabsq	$288230374541099007, %r9        # imm = 0x3FFFFFF9FFFFFFF
	leaq	1610612729(%r9), %r10
	movabsq	$-288230374541099008, %r11      # imm = 0xFC00000060000000
	movabsq	$549755816961, %rbx             # imm = 0x8000000C01
	xorl	%r14d, %r14d
	xorl	%esi, %esi
.LBB13_1:                               # =>This Inner Loop Header: Depth=1
	movq	(%rdi,%r8), %rcx
	movq	%r9, %rax
	subq	64(%rdi,%r8), %rax
	leaq	(%rax,%rax,2), %rax
	leaq	(%rcx,%rax,2), %rax
	leaq	48(,%rax,8), %rax
	movq	%rax, %rdx
	shrq	$58, %rdx
	andq	%r10, %rax
	movq	%rdx, %r15
	shlq	$29, %r15
	addq	%rax, %r15
	shlq	$30, %rdx
	addq	%r15, %rdx
	leaq	(%rdx,%r11), %rax
	cmpq	%r9, %rdx
	cmovbeq	%rdx, %rax
	movq	%rcx, 64(%rdi,%r8)
	movq	%rax, (%rdi,%r8)
	shrq	$25, %rax
	mulq	%rbx
	shrl	$4, %edx
	leal	-28(%r8), %eax
	cmpq	$4, %r14
	movzbl	%al, %ecx
	cmovbl	%r8d, %ecx
	andb	$-4, %cl
                                        # kill: def $cl killed $cl killed $ecx
	shlq	%cl, %rdx
	addl	%edx, %esi
	incq	%r14
	addq	$8, %r8
	cmpq	$8, %r14
	jne	.LBB13_1
# %bb.2:
	movl	%esi, %eax
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end13:
	.size	_Z16gq58x4_generate_P12gq58x4_state, .Lfunc_end13-_Z16gq58x4_generate_P12gq58x4_state
	.cfi_endproc
                                        # -- End function
	.section	.rodata.cst4,"aM",@progbits,4
	.p2align	2, 0x0                          # -- Begin function _Z30gq58x4_generate_uniform_float_P12gq58x4_state
.LCPI14_0:
	.long	0x2f800000                      # float 2.32830644E-10
	.text
	.globl	_Z30gq58x4_generate_uniform_float_P12gq58x4_state
	.type	_Z30gq58x4_generate_uniform_float_P12gq58x4_state,@function
_Z30gq58x4_generate_uniform_float_P12gq58x4_state: # @_Z30gq58x4_generate_uniform_float_P12gq58x4_state
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	xorl	%esi, %esi
	movabsq	$288230374541099007, %r8        # imm = 0x3FFFFFF9FFFFFFF
	leaq	1610612729(%r8), %r9
	movabsq	$-288230374541099008, %r10      # imm = 0xFC00000060000000
	movabsq	$549755816961, %r11             # imm = 0x8000000C01
	xorl	%r14d, %r14d
	xorl	%ebx, %ebx
.LBB14_1:                               # =>This Inner Loop Header: Depth=1
	movq	(%rdi,%rsi), %rcx
	movq	%r8, %rax
	subq	64(%rdi,%rsi), %rax
	leaq	(%rax,%rax,2), %rax
	leaq	(%rcx,%rax,2), %rax
	leaq	48(,%rax,8), %rax
	movq	%rax, %rdx
	shrq	$58, %rdx
	andq	%r9, %rax
	movq	%rdx, %r15
	shlq	$29, %r15
	addq	%rax, %r15
	shlq	$30, %rdx
	addq	%r15, %rdx
	leaq	(%rdx,%r10), %rax
	cmpq	%r8, %rdx
	cmovbeq	%rdx, %rax
	movq	%rcx, 64(%rdi,%rsi)
	movq	%rax, (%rdi,%rsi)
	shrq	$25, %rax
	mulq	%r11
	shrl	$4, %edx
	leal	-28(%rsi), %eax
	cmpq	$4, %r14
	movzbl	%al, %ecx
	cmovbl	%esi, %ecx
	andb	$-4, %cl
                                        # kill: def $cl killed $cl killed $ecx
	shlq	%cl, %rdx
	addl	%edx, %ebx
	incq	%r14
	addq	$8, %rsi
	cmpq	$8, %r14
	jne	.LBB14_1
# %bb.2:
	movl	%ebx, %eax
	cvtsi2ss	%rax, %xmm0
	mulss	.LCPI14_0(%rip), %xmm0
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end14:
	.size	_Z30gq58x4_generate_uniform_float_P12gq58x4_state, .Lfunc_end14-_Z30gq58x4_generate_uniform_float_P12gq58x4_state
	.cfi_endproc
                                        # -- End function
	.globl	_Z19gq58x4_print_state_P12gq58x4_state # -- Begin function _Z19gq58x4_print_state_P12gq58x4_state
	.type	_Z19gq58x4_print_state_P12gq58x4_state,@function
_Z19gq58x4_print_state_P12gq58x4_state: # @_Z19gq58x4_print_state_P12gq58x4_state
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r13
	.cfi_def_cfa_offset 32
	pushq	%r12
	.cfi_def_cfa_offset 40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r13, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	movq	%rdi, %rbx
	movl	$.L.str, %edi
	xorl	%eax, %eax
	callq	printf
	movabsq	$34359738561, %r14              # imm = 0x8000000C1
	movabsq	$288230374541099008, %r15       # imm = 0x3FFFFFFA0000000
	movl	$.L.str.3, %r12d
	xorl	%r13d, %r13d
.LBB15_1:                               # =>This Inner Loop Header: Depth=1
	movq	(%rbx,%r13,8), %rsi
	movq	%rsi, %rax
	shrq	$29, %rax
	mulq	%r14
	imulq	%r15, %rdx
	subq	%rdx, %rsi
	movl	$.L.str.1, %edi
	xorl	%eax, %eax
	callq	printf
	cmpq	$7, %r13
	movl	$.L.str.2, %edi
	cmoveq	%r12, %rdi
	xorl	%eax, %eax
	callq	printf
	incq	%r13
	cmpq	$8, %r13
	jne	.LBB15_1
# %bb.2:                                # %.preheader.preheader
	movl	$.L.str.4, %r12d
	xorl	%r13d, %r13d
.LBB15_3:                               # %.preheader
                                        # =>This Inner Loop Header: Depth=1
	movq	64(%rbx,%r13,8), %rsi
	movq	%rsi, %rax
	shrq	$29, %rax
	mulq	%r14
	imulq	%r15, %rdx
	subq	%rdx, %rsi
	movl	$.L.str.1, %edi
	xorl	%eax, %eax
	callq	printf
	cmpq	$7, %r13
	movl	$.L.str.2, %edi
	cmoveq	%r12, %rdi
	xorl	%eax, %eax
	callq	printf
	incq	%r13
	cmpq	$8, %r13
	jne	.LBB15_3
# %bb.4:
	popq	%rbx
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end15:
	.size	_Z19gq58x4_print_state_P12gq58x4_state, .Lfunc_end15-_Z19gq58x4_print_state_P12gq58x4_state
	.cfi_endproc
                                        # -- End function
	.globl	_Z23gq58x4_print_sse_state_P12gq58x4_state # -- Begin function _Z23gq58x4_print_sse_state_P12gq58x4_state
	.type	_Z23gq58x4_print_sse_state_P12gq58x4_state,@function
_Z23gq58x4_print_sse_state_P12gq58x4_state: # @_Z23gq58x4_print_sse_state_P12gq58x4_state
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r13
	.cfi_def_cfa_offset 32
	pushq	%r12
	.cfi_def_cfa_offset 40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r13, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	movq	%rdi, %rbx
	movl	$.L.str, %edi
	xorl	%eax, %eax
	callq	printf
	movabsq	$34359738561, %r14              # imm = 0x8000000C1
	movabsq	$288230374541099008, %r15       # imm = 0x3FFFFFFA0000000
	movl	$.L.str.3, %r12d
	xorl	%r13d, %r13d
.LBB16_1:                               # =>This Inner Loop Header: Depth=1
	movq	(%rbx,%r13,8), %rsi
	movq	%rsi, %rax
	shrq	$29, %rax
	mulq	%r14
	imulq	%r15, %rdx
	subq	%rdx, %rsi
	movl	$.L.str.1, %edi
	xorl	%eax, %eax
	callq	printf
	cmpq	$7, %r13
	movl	$.L.str.2, %edi
	cmoveq	%r12, %rdi
	xorl	%eax, %eax
	callq	printf
	incq	%r13
	cmpq	$8, %r13
	jne	.LBB16_1
# %bb.2:                                # %.preheader.preheader
	movl	$.L.str.4, %r12d
	xorl	%r13d, %r13d
.LBB16_3:                               # %.preheader
                                        # =>This Inner Loop Header: Depth=1
	movq	64(%rbx,%r13,8), %rsi
	movq	%rsi, %rax
	shrq	$29, %rax
	mulq	%r14
	imulq	%r15, %rdx
	subq	%rdx, %rsi
	movl	$.L.str.1, %edi
	xorl	%eax, %eax
	callq	printf
	cmpq	$7, %r13
	movl	$.L.str.2, %edi
	cmoveq	%r12, %rdi
	xorl	%eax, %eax
	callq	printf
	incq	%r13
	cmpq	$8, %r13
	jne	.LBB16_3
# %bb.4:
	popq	%rbx
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end16:
	.size	_Z23gq58x4_print_sse_state_P12gq58x4_state, .Lfunc_end16-_Z23gq58x4_print_sse_state_P12gq58x4_state
	.cfi_endproc
                                        # -- End function
	.globl	_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl # -- Begin function _Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.type	_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl,@function
_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl: # @_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r13
	.cfi_def_cfa_offset 32
	pushq	%r12
	.cfi_def_cfa_offset 40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	subq	$112, %rsp
	.cfi_def_cfa_offset 160
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r13, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rax
	movq	%rdi, (%rax)
	leaq	32(%rsp), %rcx
	movq	%rsi, (%rcx)
	leaq	24(%rsp), %rsi
	movq	%rdx, (%rsi)
	leaq	80(%rsp), %rbx
	movq	%rax, (%rbx)
	movq	%rcx, 8(%rbx)
	movq	%rsi, 16(%rbx)
	leaq	64(%rsp), %r14
	leaq	48(%rsp), %r15
	leaq	16(%rsp), %r12
	leaq	8(%rsp), %r13
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	%r12, %rdx
	movq	%r13, %rcx
	callq	__hipPopCallConfiguration
	movq	(%r14), %rsi
	movl	8(%r14), %edx
	movq	(%r15), %rcx
	movl	8(%r15), %r8d
	movl	$_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, %edi
	movq	%rbx, %r9
	pushq	(%r13)
	.cfi_adjust_cfa_offset 8
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$128, %rsp
	.cfi_adjust_cfa_offset -128
	popq	%rbx
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end17:
	.size	_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, .Lfunc_end17-_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.cfi_endproc
                                        # -- End function
	.globl	_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl # -- Begin function _Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl
	.type	_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl,@function
_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl: # @_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	subq	$24, %rsp
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movq	%rsi, %rbx
	movq	%rdi, %r14
	leaq	2047(%rdx), %rcx
	testq	%rdx, %rdx
	cmovnsq	%rdx, %rcx
	movq	%rcx, %rax
	sarq	$11, %rax
	movq	%rax, 16(%rsp)
	andq	$-2048, %rcx                    # imm = 0xF800
	cmpq	%rdx, %rcx
	jge	.LBB18_2
# %bb.1:
	incq	%rax
	movq	%rax, 16(%rsp)
.LBB18_2:
	leaq	8(%rsp), %rdi
	movl	$128, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB18_3
# %bb.5:
	movq	%rsp, %rdi
	movl	$8, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB18_6
# %bb.7:
	movq	8(%rsp), %rdi
	movl	$128, %edx
	movq	%r14, %rsi
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB18_8
# %bb.9:
	movq	(%rsp), %rdi
	leaq	16(%rsp), %rsi
	movl	$8, %edx
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB18_10
# %bb.11:
	movabsq	$4294967424, %rdi               # imm = 0x100000080
	movl	$1, %esi
	movq	%rdi, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB18_13
# %bb.12:
	movq	8(%rsp), %rdi
	movq	(%rsp), %rdx
	movq	%rbx, %rsi
	callq	_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
.LBB18_13:
	callq	hipGetLastError
	testl	%eax, %eax
	jne	.LBB18_14
# %bb.15:
	movq	8(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB18_16
# %bb.17:
	movq	(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB18_16
# %bb.18:
	addq	$24, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	retq
.LBB18_16:
	.cfi_def_cfa_offset 48
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$352, %ecx                      # imm = 0x160
	jmp	.LBB18_4
.LBB18_3:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$344, %ecx                      # imm = 0x158
	jmp	.LBB18_4
.LBB18_6:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$345, %ecx                      # imm = 0x159
	jmp	.LBB18_4
.LBB18_8:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$346, %ecx                      # imm = 0x15A
	jmp	.LBB18_4
.LBB18_10:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$347, %ecx                      # imm = 0x15B
	jmp	.LBB18_4
.LBB18_14:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$350, %ecx                      # imm = 0x15E
.LBB18_4:
	xorl	%eax, %eax
	callq	printf
	movl	$1, %edi
	callq	exit
.Lfunc_end18:
	.size	_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl, .Lfunc_end18-_Z26gq58x4_generate_gpu_array_P12gq58x4_statePjl
	.cfi_endproc
                                        # -- End function
	.globl	_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl # -- Begin function _Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.type	_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl,@function
_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl: # @_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r13
	.cfi_def_cfa_offset 32
	pushq	%r12
	.cfi_def_cfa_offset 40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	subq	$112, %rsp
	.cfi_def_cfa_offset 160
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r13, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rax
	movq	%rdi, (%rax)
	leaq	32(%rsp), %rcx
	movq	%rsi, (%rcx)
	leaq	24(%rsp), %rsi
	movq	%rdx, (%rsi)
	leaq	80(%rsp), %rbx
	movq	%rax, (%rbx)
	movq	%rcx, 8(%rbx)
	movq	%rsi, 16(%rbx)
	leaq	64(%rsp), %r14
	leaq	48(%rsp), %r15
	leaq	16(%rsp), %r12
	leaq	8(%rsp), %r13
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	%r12, %rdx
	movq	%r13, %rcx
	callq	__hipPopCallConfiguration
	movq	(%r14), %rsi
	movl	8(%r14), %edx
	movq	(%r15), %rcx
	movl	8(%r15), %r8d
	movl	$_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, %edi
	movq	%rbx, %r9
	pushq	(%r13)
	.cfi_adjust_cfa_offset 8
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$128, %rsp
	.cfi_adjust_cfa_offset -128
	popq	%rbx
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end19:
	.size	_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, .Lfunc_end19-_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.cfi_endproc
                                        # -- End function
	.globl	_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl # -- Begin function _Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl
	.type	_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl,@function
_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl: # @_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	subq	$24, %rsp
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movq	%rsi, %rbx
	movq	%rdi, %r14
	leaq	2047(%rdx), %rcx
	testq	%rdx, %rdx
	cmovnsq	%rdx, %rcx
	movq	%rcx, %rax
	sarq	$11, %rax
	movq	%rax, 16(%rsp)
	andq	$-2048, %rcx                    # imm = 0xF800
	cmpq	%rdx, %rcx
	jge	.LBB20_2
# %bb.1:
	incq	%rax
	movq	%rax, 16(%rsp)
.LBB20_2:
	leaq	8(%rsp), %rdi
	movl	$128, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB20_3
# %bb.5:
	movq	%rsp, %rdi
	movl	$8, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB20_6
# %bb.7:
	movq	8(%rsp), %rdi
	movl	$128, %edx
	movq	%r14, %rsi
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB20_8
# %bb.9:
	movq	(%rsp), %rdi
	leaq	16(%rsp), %rsi
	movl	$8, %edx
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB20_10
# %bb.11:
	movabsq	$4294967424, %rdi               # imm = 0x100000080
	movl	$1, %esi
	movq	%rdi, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB20_13
# %bb.12:
	movq	8(%rsp), %rdi
	movq	(%rsp), %rdx
	movq	%rbx, %rsi
	callq	_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
.LBB20_13:
	callq	hipGetLastError
	testl	%eax, %eax
	jne	.LBB20_14
# %bb.15:
	movq	8(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB20_16
# %bb.17:
	movq	(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB20_16
# %bb.18:
	addq	$24, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	retq
.LBB20_16:
	.cfi_def_cfa_offset 48
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$401, %ecx                      # imm = 0x191
	jmp	.LBB20_4
.LBB20_3:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$393, %ecx                      # imm = 0x189
	jmp	.LBB20_4
.LBB20_6:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$394, %ecx                      # imm = 0x18A
	jmp	.LBB20_4
.LBB20_8:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$395, %ecx                      # imm = 0x18B
	jmp	.LBB20_4
.LBB20_10:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$396, %ecx                      # imm = 0x18C
	jmp	.LBB20_4
.LBB20_14:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$399, %ecx                      # imm = 0x18F
.LBB20_4:
	xorl	%eax, %eax
	callq	printf
	movl	$1, %edi
	callq	exit
.Lfunc_end20:
	.size	_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl, .Lfunc_end20-_Z32gq58x4_generate_gpu_array_float_P12gq58x4_statePfl
	.cfi_endproc
                                        # -- End function
	.globl	_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl # -- Begin function _Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.type	_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl,@function
_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl: # @_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r13
	.cfi_def_cfa_offset 32
	pushq	%r12
	.cfi_def_cfa_offset 40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	subq	$112, %rsp
	.cfi_def_cfa_offset 160
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r13, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rax
	movq	%rdi, (%rax)
	leaq	32(%rsp), %rcx
	movq	%rsi, (%rcx)
	leaq	24(%rsp), %rsi
	movq	%rdx, (%rsi)
	leaq	80(%rsp), %rbx
	movq	%rax, (%rbx)
	movq	%rcx, 8(%rbx)
	movq	%rsi, 16(%rbx)
	leaq	64(%rsp), %r14
	leaq	48(%rsp), %r15
	leaq	16(%rsp), %r12
	leaq	8(%rsp), %r13
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	%r12, %rdx
	movq	%r13, %rcx
	callq	__hipPopCallConfiguration
	movq	(%r14), %rsi
	movl	8(%r14), %edx
	movq	(%r15), %rcx
	movl	8(%r15), %r8d
	movl	$_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, %edi
	movq	%rbx, %r9
	pushq	(%r13)
	.cfi_adjust_cfa_offset 8
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$128, %rsp
	.cfi_adjust_cfa_offset -128
	popq	%rbx
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end21:
	.size	_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, .Lfunc_end21-_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.cfi_endproc
                                        # -- End function
	.globl	_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl # -- Begin function _Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl
	.type	_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl,@function
_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl: # @_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	subq	$24, %rsp
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movq	%rsi, %rbx
	movq	%rdi, %r14
	leaq	2047(%rdx), %rcx
	testq	%rdx, %rdx
	cmovnsq	%rdx, %rcx
	movq	%rcx, %rax
	sarq	$11, %rax
	movq	%rax, 16(%rsp)
	andq	$-2048, %rcx                    # imm = 0xF800
	cmpq	%rdx, %rcx
	jge	.LBB22_2
# %bb.1:
	incq	%rax
	movq	%rax, 16(%rsp)
.LBB22_2:
	leaq	8(%rsp), %rdi
	movl	$128, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB22_3
# %bb.5:
	movq	%rsp, %rdi
	movl	$8, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB22_6
# %bb.7:
	movq	8(%rsp), %rdi
	movl	$128, %edx
	movq	%r14, %rsi
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB22_8
# %bb.9:
	movq	(%rsp), %rdi
	leaq	16(%rsp), %rsi
	movl	$8, %edx
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB22_10
# %bb.11:
	movabsq	$4294967424, %rdi               # imm = 0x100000080
	movl	$1, %esi
	movq	%rdi, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB22_13
# %bb.12:
	movq	8(%rsp), %rdi
	movq	(%rsp), %rdx
	movq	%rbx, %rsi
	callq	_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
.LBB22_13:
	callq	hipGetLastError
	testl	%eax, %eax
	jne	.LBB22_14
# %bb.15:
	movq	8(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB22_16
# %bb.17:
	movq	(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB22_16
# %bb.18:
	addq	$24, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	retq
.LBB22_16:
	.cfi_def_cfa_offset 48
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$450, %ecx                      # imm = 0x1C2
	jmp	.LBB22_4
.LBB22_3:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$442, %ecx                      # imm = 0x1BA
	jmp	.LBB22_4
.LBB22_6:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$443, %ecx                      # imm = 0x1BB
	jmp	.LBB22_4
.LBB22_8:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$444, %ecx                      # imm = 0x1BC
	jmp	.LBB22_4
.LBB22_10:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$445, %ecx                      # imm = 0x1BD
	jmp	.LBB22_4
.LBB22_14:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$448, %ecx                      # imm = 0x1C0
.LBB22_4:
	xorl	%eax, %eax
	callq	printf
	movl	$1, %edi
	callq	exit
.Lfunc_end22:
	.size	_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl, .Lfunc_end22-_Z33gq58x4_generate_gpu_array_double_P12gq58x4_statePdl
	.cfi_endproc
                                        # -- End function
	.globl	_Z22gq58x4_generate_array_P12gq58x4_statePjl # -- Begin function _Z22gq58x4_generate_array_P12gq58x4_statePjl
	.type	_Z22gq58x4_generate_array_P12gq58x4_statePjl,@function
_Z22gq58x4_generate_array_P12gq58x4_statePjl: # @_Z22gq58x4_generate_array_P12gq58x4_statePjl
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$40, %rsp
	.cfi_def_cfa_offset 80
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	movq	%rdx, %rbx
	movq	%rsi, %r14
	movq	%rdi, %r15
	leaq	2047(%rdx), %rax
	testq	%rdx, %rdx
	cmovnsq	%rdx, %rax
	movq	%rax, %r12
	sarq	$11, %r12
	movq	%r12, 32(%rsp)
	andq	$-2048, %rax                    # imm = 0xF800
	cmpq	%rdx, %rax
	jge	.LBB23_2
# %bb.1:
	incq	%r12
	movq	%r12, 32(%rsp)
.LBB23_2:
	leaq	24(%rsp), %rdi
	movl	$128, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB23_3
# %bb.5:
	shlq	$13, %r12
	leaq	16(%rsp), %rdi
	movq	%r12, %rsi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB23_6
# %bb.7:
	leaq	8(%rsp), %rdi
	movl	$8, %esi
	callq	hipMalloc
	testl	%eax, %eax
	jne	.LBB23_8
# %bb.9:
	movq	24(%rsp), %rdi
	movl	$128, %edx
	movq	%r15, %rsi
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB23_10
# %bb.11:
	movq	8(%rsp), %rdi
	leaq	32(%rsp), %rsi
	movl	$8, %edx
	movl	$1, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB23_12
# %bb.13:
	movabsq	$4294967424, %rdi               # imm = 0x100000080
	movl	$1, %esi
	movq	%rdi, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB23_15
# %bb.14:
	movq	24(%rsp), %rdi
	movq	16(%rsp), %rsi
	movq	8(%rsp), %rdx
	callq	_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
.LBB23_15:
	callq	hipGetLastError
	testl	%eax, %eax
	jne	.LBB23_16
# %bb.17:
	movq	16(%rsp), %rsi
	shlq	$2, %rbx
	movq	%r14, %rdi
	movq	%rbx, %rdx
	movl	$2, %ecx
	callq	hipMemcpy
	testl	%eax, %eax
	jne	.LBB23_18
# %bb.19:
	movq	24(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB23_20
# %bb.21:
	movq	16(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB23_20
# %bb.22:
	movq	8(%rsp), %rdi
	callq	hipFree
	testl	%eax, %eax
	jne	.LBB23_23
# %bb.24:
	addq	$40, %rsp
	.cfi_def_cfa_offset 40
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.LBB23_20:
	.cfi_def_cfa_offset 80
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$473, %ecx                      # imm = 0x1D9
	jmp	.LBB23_4
.LBB23_3:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$463, %ecx                      # imm = 0x1CF
	jmp	.LBB23_4
.LBB23_6:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$464, %ecx                      # imm = 0x1D0
	jmp	.LBB23_4
.LBB23_8:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$465, %ecx                      # imm = 0x1D1
	jmp	.LBB23_4
.LBB23_10:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$466, %ecx                      # imm = 0x1D2
	jmp	.LBB23_4
.LBB23_12:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$467, %ecx                      # imm = 0x1D3
	jmp	.LBB23_4
.LBB23_16:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$470, %ecx                      # imm = 0x1D6
	jmp	.LBB23_4
.LBB23_18:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$472, %ecx                      # imm = 0x1D8
	jmp	.LBB23_4
.LBB23_23:
	callq	hipGetLastError
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.5, %edi
	movl	$.L.str.6, %edx
	movq	%rax, %rsi
	movl	$474, %ecx                      # imm = 0x1DA
.LBB23_4:
	xorl	%eax, %eax
	callq	printf
	movl	$1, %edi
	callq	exit
.Lfunc_end23:
	.size	_Z22gq58x4_generate_array_P12gq58x4_statePjl, .Lfunc_end23-_Z22gq58x4_generate_array_P12gq58x4_statePjl
	.cfi_endproc
                                        # -- End function
	.p2align	4, 0x90                         # -- Begin function __hip_module_ctor
	.type	__hip_module_ctor,@function
__hip_module_ctor:                      # @__hip_module_ctor
	.cfi_startproc
# %bb.0:
	pushq	%rbx
	.cfi_def_cfa_offset 16
	subq	$32, %rsp
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -16
	movq	__hip_gpubin_handle(%rip), %rbx
	testq	%rbx, %rbx
	jne	.LBB24_2
# %bb.1:
	movl	$__hip_fatbin_wrapper, %edi
	callq	__hipRegisterFatBinary
	movq	%rax, %rbx
	movq	%rax, __hip_gpubin_handle(%rip)
.LBB24_2:
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, %esi
	movl	$.L__unnamed_1, %edx
	movl	$.L__unnamed_1, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, %esi
	movl	$.L__unnamed_2, %edx
	movl	$.L__unnamed_2, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, %esi
	movl	$.L__unnamed_3, %edx
	movl	$.L__unnamed_3, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	movl	$__hip_module_dtor, %edi
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	popq	%rbx
	.cfi_def_cfa_offset 8
	jmp	atexit                          # TAILCALL
.Lfunc_end24:
	.size	__hip_module_ctor, .Lfunc_end24-__hip_module_ctor
	.cfi_endproc
                                        # -- End function
	.p2align	4, 0x90                         # -- Begin function __hip_module_dtor
	.type	__hip_module_dtor,@function
__hip_module_dtor:                      # @__hip_module_dtor
	.cfi_startproc
# %bb.0:
	movq	__hip_gpubin_handle(%rip), %rdi
	testq	%rdi, %rdi
	je	.LBB25_2
# %bb.1:
	pushq	%rax
	.cfi_def_cfa_offset 16
	callq	__hipUnregisterFatBinary
	movq	$0, __hip_gpubin_handle(%rip)
	addq	$8, %rsp
	.cfi_def_cfa_offset 8
.LBB25_2:
	retq
.Lfunc_end25:
	.size	__hip_module_dtor, .Lfunc_end25-__hip_module_dtor
	.cfi_endproc
                                        # -- End function
	.type	gq58x4_sse_Consts,@object       # @gq58x4_sse_Consts
	.data
	.globl	gq58x4_sse_Consts
	.p2align	4, 0x0
gq58x4_sse_Consts:
	.quad	-4611686095736799232            # 0xbfffffee00000000
	.quad	-4611686095736799232            # 0xbfffffee00000000
	.quad	1610612736                      # 0x60000000
	.quad	1610612736                      # 0x60000000
	.quad	288230371923853311              # 0x3ffffff03ffffff
	.quad	288230371923853311              # 0x3ffffff03ffffff
	.quad	288230374541099008              # 0x3ffffffa0000000
	.quad	288230374541099008              # 0x3ffffffa0000000
	.size	gq58x4_sse_Consts, 64

	.type	.L.str,@object                  # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"Generator State:\nxN={"
	.size	.L.str, 22

	.type	.L.str.1,@object                # @.str.1
.L.str.1:
	.asciz	"%llu"
	.size	.L.str.1, 5

	.type	.L.str.2,@object                # @.str.2
.L.str.2:
	.asciz	","
	.size	.L.str.2, 2

	.type	.L.str.3,@object                # @.str.3
.L.str.3:
	.asciz	"}\nxP={"
	.size	.L.str.3, 7

	.type	.L.str.4,@object                # @.str.4
.L.str.4:
	.asciz	"}\n\n"
	.size	.L.str.4, 4

	.type	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl,@object # @_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.section	.rodata,"a",@progbits
	.globl	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.p2align	3, 0x0
_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl:
	.quad	_Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.size	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, 8

	.type	.L.str.5,@object                # @.str.5
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.5:
	.asciz	"Error: %s at %s:%d\n"
	.size	.L.str.5, 20

	.type	.L.str.6,@object                # @.str.6
.L.str.6:
	.asciz	"/home/ubuntu/Datasets/stackv2/train-structured-repos-hip-sm89/sbinet-staging/3photons/master/Random/aesb_v1_0/source/_gq58x4.hip"
	.size	.L.str.6, 129

	.type	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl,@object # @_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.section	.rodata,"a",@progbits
	.globl	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.p2align	3, 0x0
_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl:
	.quad	_Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.size	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, 8

	.type	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl,@object # @_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.globl	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.p2align	3, 0x0
_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl:
	.quad	_Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.size	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, 8

	.type	.L__unnamed_1,@object           # @0
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__unnamed_1:
	.asciz	"_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl"
	.size	.L__unnamed_1, 52

	.type	.L__unnamed_2,@object           # @1
.L__unnamed_2:
	.asciz	"_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl"
	.size	.L__unnamed_2, 58

	.type	.L__unnamed_3,@object           # @2
.L__unnamed_3:
	.asciz	"_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl"
	.size	.L__unnamed_3, 59

	.type	__hip_fatbin_wrapper,@object    # @__hip_fatbin_wrapper
	.section	.hipFatBinSegment,"a",@progbits
	.p2align	3, 0x0
__hip_fatbin_wrapper:
	.long	1212764230                      # 0x48495046
	.long	1                               # 0x1
	.quad	__hip_fatbin
	.quad	0
	.size	__hip_fatbin_wrapper, 24

	.type	__hip_gpubin_handle,@object     # @__hip_gpubin_handle
	.local	__hip_gpubin_handle
	.comm	__hip_gpubin_handle,8,8
	.section	.init_array,"aw",@init_array
	.p2align	3, 0x0
	.quad	__hip_module_ctor
	.type	__hip_cuid_,@object             # @__hip_cuid_
	.bss
	.globl	__hip_cuid_
__hip_cuid_:
	.byte	0                               # 0x0
	.size	__hip_cuid_, 1

	.ident	"AMD clang version 18.0.0git (https://github.com/RadeonOpenCompute/llvm-project roc-6.3.2 25012 e5bf7e55c91490b07c49d8960fa7983d864936c4)"
	.section	".note.GNU-stack","",@progbits
	.addrsig
	.addrsig_sym _Z43__device_stub__gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.addrsig_sym _Z49__device_stub__gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.addrsig_sym _Z50__device_stub__gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.addrsig_sym __hip_module_ctor
	.addrsig_sym __hip_module_dtor
	.addrsig_sym gq58x4_sse_Consts
	.addrsig_sym _Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.addrsig_sym _Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.addrsig_sym _Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.addrsig_sym __hip_fatbin
	.addrsig_sym __hip_fatbin_wrapper
	.addrsig_sym __hip_cuid_

	.text
	.amdgcn_target "amdgcn-amd-amdhsa--gfx1100"
	.p2align	2                               ; -- Begin function _Z15gq58x4_GetNextNyyj
	.type	_Z15gq58x4_GetNextNyyj,@function
_Z15gq58x4_GetNextNyyj:                 ; @_Z15gq58x4_GetNextNyyj
; %bb.0:
	s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
	s_xor_saveexec_b32 s0, -1
	scratch_store_b32 off, v32, s32         ; 4-byte Folded Spill
	s_mov_b32 exec_lo, s0
	v_writelane_b32 v32, s34, 0
	v_writelane_b32 v32, s35, 1
	v_writelane_b32 v32, s36, 2
	v_writelane_b32 v32, s37, 3
	v_writelane_b32 v32, s38, 4
	v_writelane_b32 v32, s39, 5
	v_writelane_b32 v32, s30, 6
	v_writelane_b32 v32, s31, 7
	v_mov_b32_e32 v6, v1
	s_mov_b32 s3, 0
	s_mov_b32 s14, exec_lo
	v_cmpx_ne_u32_e32 0, v4
	s_cbranch_execz .LBB0_4
; %bb.1:                                ; %.lr.ph
	v_mov_b32_e32 v5, 0
	s_mov_b64 s[4:5], 0xffffffff
	s_brev_b32 s6, -7
	s_mov_b64 s[10:11], 8
	s_mov_b32 s7, 0x3ffffff
	v_mov_b32_e32 v1, v5
	s_mov_b64 s[12:13], 48
	s_mov_b32 s8, -2
	s_mov_b32 s15, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[8:9], null, v6, 12, v[0:1]
	v_add_co_u32 v0, vcc_lo, v8, 12
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v1, vcc_lo, -1, v9, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[4:5], v[8:9]
	v_dual_cndmask_b32 v8, v8, v0 :: v_dual_cndmask_b32 v7, v9, v1
	v_cndmask_b32_e64 v1, 0, 1, vcc_lo
	s_delay_alu instid0(VALU_DEP_1)
	v_add_co_u32 v6, s0, v6, v1
	v_mov_b32_e32 v0, v4
	v_add_co_ci_u32_e64 v9, null, 0, 0, s0
	v_mov_b32_e32 v1, v5
.LBB0_2:                                ; =>This Inner Loop Header: Depth=1
	s_mul_i32 s2, s11, 12
	s_mul_hi_u32 s0, s11, 12
	s_add_u32 s18, s2, s10
	v_mov_b32_e32 v4, v2
	s_addc_u32 s19, s0, 0
	s_add_u32 s0, s18, 12
	v_cmp_gt_u64_e64 s2, s[18:19], s[4:5]
	s_addc_u32 s10, s19, -1
	v_mad_u64_u32 v[11:12], null, v3, 12, v[4:5]
	v_mov_b32_e32 v10, v3
	s_mov_b32 s1, s11
	s_delay_alu instid0(VALU_DEP_3)
	v_cndmask_b32_e64 v2, 0, 1, s2
	s_and_b32 s2, s2, exec_lo
	s_cselect_b32 s2, s10, s19
	s_cselect_b32 s19, s0, s18
	s_mov_b32 s16, s13
	v_readfirstlane_b32 s17, v2
	v_add_co_u32 v2, s0, v11, 12
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_4)
	v_add_co_ci_u32_e64 v3, s0, -1, v12, s0
	v_cmp_lt_u64_e64 s0, s[4:5], v[11:12]
	s_add_u32 s10, s1, s17
	s_addc_u32 s17, 0, 0
	s_mul_hi_u32 s1, s10, 0x90
	s_mul_i32 s26, s17, 0x90
	s_mul_hi_u32 s11, s13, 12
	v_cndmask_b32_e64 v14, 0, 1, s0
	s_mul_i32 s13, s13, 12
	v_cndmask_b32_e64 v4, v11, v2, s0
	s_add_i32 s26, s1, s26
	v_cndmask_b32_e64 v13, v12, v3, s0
	s_add_u32 s0, s13, s12
	s_addc_u32 s1, s11, 0
	v_add_co_u32 v22, s11, v10, v14
	v_mul_lo_u32 v15, v4, s17
	v_mad_u64_u32 v[2:3], null, v4, s10, 0
	v_mul_lo_u32 v16, v4, s2
	v_mad_u64_u32 v[11:12], null, v4, s19, 0
	v_add_co_ci_u32_e64 v4, null, 0, 0, s11
	v_cmp_gt_u64_e64 s11, s[0:1], s[4:5]
	v_mul_lo_u32 v10, v13, s10
	v_mul_lo_u32 v13, v13, s19
	s_mul_i32 s23, s10, 0x90
	s_mul_i32 s20, s19, s2
	s_mul_i32 s25, s2, s10
	v_cndmask_b32_e64 v14, 0, 1, s11
	s_add_u32 s12, s0, 12
	v_mul_lo_u32 v20, v22, s2
	s_mul_hi_u32 s24, s19, s10
	s_mul_i32 s18, s19, s10
	v_readfirstlane_b32 s2, v14
	s_mul_hi_u32 s29, s23, s10
	s_mul_i32 s30, s23, s10
	s_mul_i32 s13, s26, s10
	s_addc_u32 s10, s1, -1
	v_add3_u32 v3, v3, v15, v10
	v_add3_u32 v10, v12, v16, v13
	s_and_b32 s11, s11, exec_lo
	s_cselect_b32 s11, s10, s1
	s_cselect_b32 s10, s12, s0
	s_mul_i32 s27, s19, s17
	v_alignbit_b32 v27, s11, s10, 31
	s_add_u32 s34, s16, s2
	v_mul_lo_u32 v21, v4, s19
	v_mul_lo_u32 v23, s23, v4
	s_addc_u32 s35, 0, 0
	s_add_i32 s0, s24, s27
	v_lshrrev_b32_e32 v4, 26, v10
	s_mul_hi_u32 s21, s19, s19
	s_mul_i32 s22, s19, s19
	v_mul_lo_u32 v18, s11, v6
	v_mul_lo_u32 v19, s10, v9
	v_mad_u64_u32 v[12:13], null, s10, v6, 0
	v_mad_u64_u32 v[16:17], null, v22, s19, v[2:3]
	s_add_i32 s19, s0, s25
	s_mul_i32 s28, s23, s17
	v_readfirstlane_b32 s25, v27
	v_alignbit_b32 v27, s19, s18, 25
	s_add_i32 s1, s29, s28
	v_lshlrev_b64 v[2:3], 29, v[4:5]
	v_alignbit_b32 v30, s35, s34, 25
	s_add_i32 s2, s21, s20
	s_add_i32 s24, s1, s13
	s_lshl_b64 s[0:1], s[18:19], 1
	v_and_b32_e32 v10, 0x3ffffff, v10
	s_add_i32 s20, s2, s20
	s_and_b32 s0, s0, 0x3fffffe
	v_readfirstlane_b32 s37, v27
	v_add3_u32 v13, v13, v19, v18
	v_lshlrev_b64 v[18:19], 30, v[4:5]
	s_lshr_b32 s2, s20, 26
	s_and_b32 s18, s20, 0x3ffffff
	v_readfirstlane_b32 s19, v30
	s_mul_hi_u32 s20, s0, -12
	s_mul_i32 s36, s0, -12
	v_add3_u32 v4, v21, v17, v20
	v_add_co_u32 v2, s0, v2, v11
	s_lshr_b32 s1, s1, 26
	v_add_co_ci_u32_e64 v3, s0, v3, v10, s0
	s_mul_hi_u32 s16, s34, 0x90
	s_mul_i32 s17, s35, 0x90
	s_mul_i32 s1, s1, 0x30000000
	s_mul_hi_u32 s0, s37, 0x30000000
	v_mul_lo_u32 v25, s11, v8
	v_mul_lo_u32 v26, s10, v7
	v_mad_u64_u32 v[14:15], null, s10, v8, 0
	v_mul_lo_u32 v28, s34, v7
	v_mul_lo_u32 v29, s35, v8
	s_add_i32 s29, s16, s17
	s_lshl_b64 s[16:17], s[2:3], 29
	v_mad_u64_u32 v[20:21], null, s34, v8, v[12:13]
	s_mul_hi_u32 s38, s19, 0x30000000
	s_mul_i32 s39, s19, 0x30000000
	s_mul_i32 s19, s37, 0x30000000
	v_alignbit_b32 v12, v4, v16, 26
	s_add_i32 s37, s0, s1
	v_add_co_u32 v2, s0, v2, v18
	s_add_u32 s16, s16, s22
	v_add_co_ci_u32_e64 v3, s0, v3, v19, s0
	s_addc_u32 s17, s17, s18
	s_lshl_b64 s[0:1], s[2:3], 30
	v_mad_u64_u32 v[10:11], null, 0x30000000, v12, 0
	s_add_u32 s16, s16, s0
	v_add_co_u32 v12, s0, 0x60000000, v2
	s_addc_u32 s17, s17, s1
	v_add3_u32 v25, v15, v26, v25
	v_add_co_ci_u32_e64 v15, s0, 0xfc000000, v3, s0
	v_lshrrev_b32_e32 v13, 26, v4
	v_add3_u32 v4, v29, v21, v28
	v_cmp_gt_u64_e64 s2, s[16:17], s[6:7]
	v_cmp_lt_u64_e64 s0, s[6:7], v[2:3]
	s_add_u32 s1, s16, 0x60000000
	v_and_b32_e32 v17, 0x3ffffff, v16
	s_addc_u32 s18, s17, 0xfc000000
	v_alignbit_b32 v16, v4, v20, 26
	v_and_b32_e32 v18, 0x3ffffff, v20
	v_cndmask_b32_e64 v20, v3, v15, s0
	v_cndmask_b32_e64 v21, v2, v12, s0
	s_and_b32 s0, s2, exec_lo
	s_cselect_b32 s0, s18, s17
	s_cselect_b32 s1, s1, s16
	s_add_u32 s2, s30, s19
	v_lshrrev_b32_e32 v19, 26, v4
	v_mov_b32_e32 v4, v11
	s_addc_u32 s16, s24, s37
	s_add_u32 s2, s2, s36
	v_mad_u64_u32 v[2:3], null, 0x30000000, v16, 0
	s_addc_u32 s16, s16, s20
	s_add_u32 s1, s2, s1
	s_addc_u32 s0, s16, s0
	v_mad_u64_u32 v[11:12], null, 0x30000000, v13, v[4:5]
	s_add_u32 s16, s1, 0xa0000000
	s_addc_u32 s0, s0, 0x3ffffff
	s_delay_alu instid0(VALU_DEP_2)
	v_mad_u64_u32 v[12:13], null, 0x30000000, v19, v[3:4]
	s_lshr_b32 s2, s0, 26
	s_and_b32 s17, s0, 0x3ffffff
	s_lshl_b64 s[0:1], s[2:3], 29
	v_mul_lo_u32 v24, s26, v22
	s_add_u32 s16, s0, s16
	s_addc_u32 s17, s1, s17
	s_lshl_b64 s[0:1], s[2:3], 30
	v_mad_u64_u32 v[15:16], null, s23, v22, v[10:11]
	s_add_u32 s16, s16, s0
	s_addc_u32 s17, s17, s1
	v_mov_b32_e32 v3, v12
	v_cmp_gt_u64_e64 s2, s[16:17], s[6:7]
	s_mul_i32 s21, s34, 0x90
	s_add_u32 s1, s16, 0x60000000
	s_delay_alu instid0(VALU_DEP_3)
	v_add3_u32 v4, v24, v16, v23
	v_mul_lo_u32 v31, s21, v9
	v_mul_lo_u32 v26, s29, v6
	s_addc_u32 s18, s17, 0xfc000000
	v_mad_u64_u32 v[12:13], null, s21, v6, v[2:3]
	v_add_co_u32 v10, s0, 0xa0000000, v15
	s_and_b32 s2, s2, exec_lo
	s_mul_i32 s26, s10, s11
	s_mul_hi_u32 s31, s10, s10
	s_mul_i32 s12, s10, s10
	s_cselect_b32 s17, s18, s17
	s_cselect_b32 s16, s1, s16
	s_lshl_b64 s[10:11], s[10:11], 1
	v_add_co_ci_u32_e64 v11, s0, 0x3ffffff, v4, s0
	s_mov_b32 s9, s7
	s_lshl_b32 s1, s34, 1
	s_lshr_b32 s2, s11, 26
	s_and_b32 s20, s1, 0x3fffffe
	s_and_b64 s[18:19], s[10:11], s[8:9]
	s_lshl_b64 s[0:1], s[2:3], 29
	v_add3_u32 v3, v26, v13, v31
	s_add_u32 s18, s0, s18
	v_add_co_u32 v2, s0, 0xa0000000, v12
	v_mad_u64_u32 v[12:13], null, v17, -12, v[10:11]
	s_mul_i32 s27, s21, s35
	s_mul_hi_u32 s28, s21, s34
	s_mul_i32 s13, s21, s34
	s_mul_i32 s21, s10, s35
	s_mul_hi_u32 s22, s10, s34
	s_mul_i32 s23, s10, s34
	s_addc_u32 s1, s1, s19
	s_lshl_b64 s[10:11], s[2:3], 30
	v_add_co_ci_u32_e64 v3, s0, 0x3ffffff, v3, s0
	s_add_u32 s10, s18, s10
	s_addc_u32 s11, s1, s11
	v_add_co_u32 v19, s0, v12, v21
	v_cmp_gt_u64_e64 s2, s[10:11], s[6:7]
	v_add_co_ci_u32_e64 v12, s0, v13, v20, s0
	s_add_u32 s1, s10, 0x60000000
	s_mul_hi_u32 s24, s20, -12
	s_mul_i32 s20, s20, -12
	s_addc_u32 s18, s11, 0xfc000000
	s_and_b32 s0, s2, exec_lo
	s_cselect_b32 s0, s18, s11
	s_cselect_b32 s1, s1, s10
	s_add_u32 s2, s39, s20
	v_lshrrev_b32_e32 v4, 26, v12
	s_addc_u32 s10, s38, s24
	s_add_u32 s1, s2, s1
	s_addc_u32 s2, s10, s0
	s_add_u32 s0, s1, 0xa0000000
	v_mad_u64_u32 v[10:11], null, v18, -12, v[2:3]
	s_addc_u32 s1, s2, 0x3ffffff
	v_lshlrev_b64 v[2:3], 29, v[4:5]
	s_lshr_b32 s2, s1, 26
	v_and_b32_e32 v20, 0x3ffffff, v12
	v_lshlrev_b64 v[12:13], 30, v[4:5]
	v_lshrrev_b32_e32 v4, 26, v25
	s_and_b64 s[0:1], s[0:1], s[8:9]
	s_lshl_b64 s[10:11], s[2:3], 29
	v_and_b32_e32 v27, 0x3ffffff, v25
	s_add_u32 s9, s10, s0
	v_add_co_u32 v2, s0, v2, v19
	v_lshlrev_b64 v[15:16], 29, v[4:5]
	v_add_co_ci_u32_e64 v3, s0, v3, v20, s0
	s_delay_alu instid0(VALU_DEP_3)
	v_add_co_u32 v2, s0, v2, v12
	s_addc_u32 s1, s11, s1
	s_lshl_b64 s[10:11], s[2:3], 30
	v_lshlrev_b64 v[17:18], 30, v[4:5]
	v_add_co_ci_u32_e64 v3, s0, v3, v13, s0
	s_add_u32 s10, s9, s10
	v_add_co_u32 v4, s0, v15, v14
	s_addc_u32 s11, s1, s11
	v_add_co_ci_u32_e64 v13, s0, v16, v27, s0
	v_cmp_gt_u64_e64 s9, s[10:11], s[6:7]
	v_add_co_u32 v14, s0, 0x60000000, v2
	v_add_co_u32 v12, s1, v4, v17
	s_add_u32 s2, s10, 0x60000000
	v_add_co_ci_u32_e64 v15, s0, 0xfc000000, v3, s0
	v_add_co_ci_u32_e64 v13, s1, v13, v18, s1
	s_addc_u32 s18, s11, 0xfc000000
	v_cmp_lt_u64_e64 s0, s[6:7], v[2:3]
	s_and_b32 s1, s9, exec_lo
	s_cselect_b32 s11, s18, s11
	s_cselect_b32 s10, s2, s10
	v_add_co_u32 v4, s1, 0x60000000, v12
	v_cmp_lt_u64_e64 s18, s[16:17], s[10:11]
	v_add_co_ci_u32_e64 v16, s1, 0xfc000000, v13, s1
	v_cmp_lt_u64_e64 s1, s[6:7], v[12:13]
	v_cndmask_b32_e64 v2, v2, v14, s0
	s_add_u32 s2, s16, 0xa0000000
	v_cndmask_b32_e64 v3, v3, v15, s0
	s_addc_u32 s9, s17, 0x3ffffff
	s_and_b32 s0, s18, exec_lo
	s_cselect_b32 s2, s2, s16
	v_cndmask_b32_e64 v4, v12, v4, s1
	v_add_co_u32 v14, s0, 0xa0000000, v2
	s_cselect_b32 s9, s9, s17
	v_cndmask_b32_e64 v13, v13, v16, s1
	v_add_co_ci_u32_e64 v15, s0, 0x3ffffff, v3, s0
	s_sub_u32 s10, s2, s10
	s_mul_i32 s25, s25, s34
	s_subb_u32 s11, s9, s11
	s_add_i32 s0, s22, s21
	s_add_i32 s9, s31, s26
	s_add_i32 s16, s0, s25
	v_add_co_u32 v16, s0, v10, v4
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_3) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e64 v10, s0, v11, v13, s0
	v_alignbit_b32 v11, s16, s23, 26
	s_mul_i32 s29, s29, s34
	s_add_i32 s2, s28, s27
	v_and_b32_e32 v17, 0x3ffffff, v10
	v_lshrrev_b32_e32 v4, 26, v10
	v_readfirstlane_b32 s17, v11
	s_add_i32 s9, s9, s26
	s_lshr_b32 s0, s16, 26
	s_and_b32 s1, s23, 0x3fffffe
	v_lshlrev_b64 v[10:11], 29, v[4:5]
	s_add_i32 s18, s2, s29
	s_lshr_b32 s2, s9, 26
	s_mul_i32 s16, s0, 0x30000000
	s_mul_hi_u32 s21, s17, 0x30000000
	s_mul_hi_u32 s19, s1, -12
	s_mul_i32 s20, s1, -12
	s_lshl_b64 s[0:1], s[2:3], 29
	s_and_b32 s9, s9, 0x3ffffff
	v_lshlrev_b64 v[12:13], 30, v[4:5]
	s_add_i32 s21, s21, s16
	s_add_u32 s12, s0, s12
	v_add_co_u32 v4, s0, v10, v16
	s_mul_i32 s22, s17, 0x30000000
	s_addc_u32 s1, s1, s9
	s_lshl_b64 s[16:17], s[2:3], 30
	v_add_co_ci_u32_e64 v11, s0, v11, v17, s0
	s_add_u32 s16, s12, s16
	s_addc_u32 s17, s1, s17
	v_add_co_u32 v10, s0, v4, v12
	v_cmp_gt_u64_e64 s2, s[16:17], s[6:7]
	v_add_co_ci_u32_e64 v11, s0, v11, v13, s0
	s_add_u32 s1, s16, 0x60000000
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_co_u32 v4, s0, 0x60000000, v10
	s_addc_u32 s9, s17, 0xfc000000
	v_add_co_ci_u32_e64 v12, s0, 0xfc000000, v11, s0
	s_and_b32 s0, s2, exec_lo
	v_cmp_lt_u64_e64 s0, s[6:7], v[10:11]
	s_cselect_b32 s2, s9, s17
	s_cselect_b32 s1, s1, s16
	s_add_u32 s9, s13, s22
	s_addc_u32 s12, s18, s21
	s_add_u32 s9, s9, s20
	s_addc_u32 s12, s12, s19
	s_add_u32 s1, s9, s1
	v_cndmask_b32_e64 v11, v11, v12, s0
	v_cndmask_b32_e64 v10, v10, v4, s0
	s_addc_u32 s0, s12, s2
	s_add_u32 s1, s1, 0xa0000000
	s_addc_u32 s0, s0, 0x3ffffff
	v_add_co_u32 v0, vcc_lo, v0, -1
	s_lshr_b32 s2, s0, 26
	s_and_b32 s9, s0, 0x3ffffff
	v_cmp_lt_u64_e64 s0, v[2:3], v[10:11]
	s_lshl_b64 s[12:13], s[2:3], 29
	v_add_co_ci_u32_e32 v1, vcc_lo, -1, v1, vcc_lo
	s_add_u32 s1, s12, s1
	s_addc_u32 s9, s13, s9
	s_lshl_b64 s[12:13], s[2:3], 30
	v_cndmask_b32_e64 v2, v2, v14, s0
	s_add_u32 s12, s1, s12
	s_addc_u32 s13, s9, s13
	v_cndmask_b32_e64 v3, v3, v15, s0
	v_cmp_gt_u64_e64 s2, s[12:13], s[6:7]
	v_cmp_eq_u64_e32 vcc_lo, 0, v[0:1]
	v_sub_co_u32 v2, s0, v2, v10
	s_add_u32 s1, s12, 0x60000000
	v_sub_co_ci_u32_e64 v3, s0, v3, v11, s0
	s_addc_u32 s9, s13, 0xfc000000
	s_and_b32 s0, s2, exec_lo
	s_cselect_b32 s13, s9, s13
	s_cselect_b32 s12, s1, s12
	s_or_b32 s15, vcc_lo, s15
	s_delay_alu instid0(SALU_CYCLE_1)
	s_and_not1_b32 exec_lo, exec_lo, s15
	s_cbranch_execnz .LBB0_2
; %bb.3:                                ; %Flow
	s_or_b32 exec_lo, exec_lo, s15
.LBB0_4:                                ; %Flow45
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s14
	v_readlane_b32 s30, v32, 6
	v_dual_mov_b32 v0, v2 :: v_dual_mov_b32 v1, v3
	v_readlane_b32 s31, v32, 7
	v_readlane_b32 s39, v32, 5
	v_readlane_b32 s38, v32, 4
	v_readlane_b32 s37, v32, 3
	v_readlane_b32 s36, v32, 2
	v_readlane_b32 s35, v32, 1
	v_readlane_b32 s34, v32, 0
	s_xor_saveexec_b32 s0, -1
	scratch_load_b32 v32, off, s32          ; 4-byte Folded Reload
	s_mov_b32 exec_lo, s0
	s_waitcnt vmcnt(0)
	s_setpc_b64 s[30:31]
.Lfunc_end0:
	.size	_Z15gq58x4_GetNextNyyj, .Lfunc_end0-_Z15gq58x4_GetNextNyyj
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Function info:
; codeLenInByte = 2516
; NumSgprs: 42
; NumVgprs: 33
; ScratchSize: 8
; MemoryBound: 0
	.text
	.protected	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl ; -- Begin function _Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.globl	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
	.p2align	8
	.type	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl,@function
_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl: ; @_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
; %bb.0:
	s_clause 0x1
	s_load_b128 s[40:43], s[0:1], 0x0
	s_load_b64 s[44:45], s[0:1], 0x10
	v_mov_b32_e32 v33, v0
	s_mov_b32 s33, exec_lo
	s_mov_b32 s32, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_and_b32_e32 v50, 7, v33
	v_lshlrev_b32_e32 v51, 3, v50
	s_waitcnt lgkmcnt(0)
	s_clause 0x1
	global_load_b64 v[36:37], v51, s[40:41] offset:64
	global_load_b64 v[34:35], v51, s[40:41]
	s_load_b32 s0, s[0:1], 0x24
	s_load_b64 s[40:41], s[44:45], 0x0
	s_waitcnt lgkmcnt(0)
	s_and_b32 s0, s0, 0xffff
	s_waitcnt vmcnt(1)
	v_dual_mov_b32 v41, v37 :: v_dual_mov_b32 v40, v36
	s_waitcnt vmcnt(0)
	v_mad_u64_u32 v[0:1], null, s15, s0, v[33:34]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshrrev_b32_e32 v3, 3, v0
	v_mad_u64_u32 v[44:45], null, s40, v3, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v0, v45
	v_mad_u64_u32 v[1:2], null, s41, v3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v45, v1
	v_cmpx_ne_u64_e32 0, v[44:45]
	s_cbranch_execz .LBB1_6
; %bb.1:                                ; %.lr.ph.i.preheader
	v_mov_b32_e32 v39, v35
	v_mov_b32_e32 v41, v37
	v_dual_mov_b32 v49, v45 :: v_dual_mov_b32 v48, v44
	v_dual_mov_b32 v47, 0 :: v_dual_mov_b32 v38, v34
	v_mov_b32_e32 v40, v36
	s_brev_b32 s46, -7
	s_mov_b32 s47, 0x3ffffff
	s_mov_b32 s48, 0
	s_mov_b32 s49, 0
	s_getpc_b64 s[52:53]
	s_add_u32 s52, s52, _Z15gq58x4_GetNextNyyj@rel32@lo+4
	s_addc_u32 s53, s53, _Z15gq58x4_GetNextNyyj@rel32@hi+12
.LBB1_2:                                ; %.lr.ph.i
                                        ; =>This Inner Loop Header: Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_and_b32_e32 v0, 1, v48
	s_mov_b32 s50, exec_lo
	v_cmpx_eq_u32_e32 1, v0
	s_cbranch_execz .LBB1_4
; %bb.3:                                ;   in Loop: Header=BB1_2 Depth=1
	v_dual_mov_b32 v0, v40 :: v_dual_mov_b32 v1, v41
	v_dual_mov_b32 v2, v38 :: v_dual_mov_b32 v3, v39
	v_mov_b32_e32 v4, s49
	s_swappc_b64 s[30:31], s[52:53]
	v_sub_co_u32 v2, vcc_lo, 0xa0000000, v40
	v_dual_mov_b32 v42, v0 :: v_dual_mov_b32 v43, v1
	v_sub_co_ci_u32_e32 v4, vcc_lo, 0x3ffffff, v41, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[0:1], null, v2, 6, v[38:39]
	v_mad_u64_u32 v[2:3], null, v4, 6, v[1:2]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v1, v2
	v_lshlrev_b64 v[0:1], 3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshrrev_b32_e32 v46, 26, v1
	v_and_b32_e32 v1, 0x3ffffff, v1
	v_lshlrev_b64 v[2:3], 29, v[46:47]
	v_lshlrev_b64 v[4:5], 30, v[46:47]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v2, v0
	v_add_co_ci_u32_e32 v1, vcc_lo, v3, v1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v4
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v5, vcc_lo
	v_mov_b32_e32 v4, s49
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v2, vcc_lo, 0x60000000, v0
	v_add_co_ci_u32_e32 v3, vcc_lo, 0xfc000000, v1, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[46:47], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v2, v0, v2, vcc_lo
	v_dual_mov_b32 v0, v38 :: v_dual_cndmask_b32 v3, v1, v3
	v_mov_b32_e32 v1, v39
	s_swappc_b64 s[30:31], s[52:53]
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v38, v0 :: v_dual_mov_b32 v39, v1
	v_dual_mov_b32 v40, v42 :: v_dual_mov_b32 v41, v43
.LBB1_4:                                ;   in Loop: Header=BB1_2 Depth=1
	s_or_b32 exec_lo, exec_lo, s50
	v_lshrrev_b64 v[0:1], 1, v[48:49]
	v_cmp_gt_u64_e32 vcc_lo, 2, v[48:49]
	s_add_i32 s49, s49, 1
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_dual_mov_b32 v49, v1 :: v_dual_mov_b32 v48, v0
	s_or_b32 s48, vcc_lo, s48
	s_and_not1_b32 exec_lo, exec_lo, s48
	s_cbranch_execnz .LBB1_2
; %bb.5:                                ; %Flow64
	s_or_b32 exec_lo, exec_lo, s48
.LBB1_6:                                ; %Flow65
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s33
	v_add_co_u32 v42, vcc_lo, v44, 1
	v_add_co_ci_u32_e32 v43, vcc_lo, 0, v45, vcc_lo
	v_lshlrev_b32_e32 v46, 3, v33
	s_mov_b32 s33, exec_lo
	ds_store_b64 v46, v[40:41] offset:1024
	v_cmpx_ne_u64_e32 0, v[42:43]
	s_cbranch_execz .LBB1_12
; %bb.7:                                ; %.lr.ph.i37.preheader
	v_mov_b32_e32 v41, 0
	s_brev_b32 s46, -7
	s_mov_b32 s47, 0x3ffffff
	s_mov_b32 s48, 0
	s_mov_b32 s49, 0
	s_getpc_b64 s[52:53]
	s_add_u32 s52, s52, _Z15gq58x4_GetNextNyyj@rel32@lo+4
	s_addc_u32 s53, s53, _Z15gq58x4_GetNextNyyj@rel32@hi+12
.LBB1_8:                                ; %.lr.ph.i37
                                        ; =>This Inner Loop Header: Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_and_b32_e32 v0, 1, v42
	s_mov_b32 s50, exec_lo
	v_cmpx_eq_u32_e32 1, v0
	s_cbranch_execz .LBB1_10
; %bb.9:                                ;   in Loop: Header=BB1_8 Depth=1
	v_dual_mov_b32 v0, v36 :: v_dual_mov_b32 v1, v37
	v_dual_mov_b32 v2, v34 :: v_dual_mov_b32 v3, v35
	v_mov_b32_e32 v4, s49
	s_swappc_b64 s[30:31], s[52:53]
	v_sub_co_u32 v2, vcc_lo, 0xa0000000, v36
	v_dual_mov_b32 v38, v0 :: v_dual_mov_b32 v39, v1
	v_sub_co_ci_u32_e32 v4, vcc_lo, 0x3ffffff, v37, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[0:1], null, v2, 6, v[34:35]
	v_mad_u64_u32 v[2:3], null, v4, 6, v[1:2]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v1, v2
	v_lshlrev_b64 v[0:1], 3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshrrev_b32_e32 v40, 26, v1
	v_and_b32_e32 v1, 0x3ffffff, v1
	v_lshlrev_b64 v[2:3], 29, v[40:41]
	v_lshlrev_b64 v[4:5], 30, v[40:41]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v2, v0
	v_add_co_ci_u32_e32 v1, vcc_lo, v3, v1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v4
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v5, vcc_lo
	v_mov_b32_e32 v4, s49
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v2, vcc_lo, 0x60000000, v0
	v_add_co_ci_u32_e32 v3, vcc_lo, 0xfc000000, v1, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[46:47], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v2, v0, v2, vcc_lo
	v_dual_mov_b32 v0, v34 :: v_dual_cndmask_b32 v3, v1, v3
	v_mov_b32_e32 v1, v35
	s_swappc_b64 s[30:31], s[52:53]
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v34, v0 :: v_dual_mov_b32 v35, v1
	v_dual_mov_b32 v36, v38 :: v_dual_mov_b32 v37, v39
.LBB1_10:                               ;   in Loop: Header=BB1_8 Depth=1
	s_or_b32 exec_lo, exec_lo, s50
	v_lshrrev_b64 v[0:1], 1, v[42:43]
	v_cmp_gt_u64_e32 vcc_lo, 2, v[42:43]
	s_add_i32 s49, s49, 1
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_dual_mov_b32 v43, v1 :: v_dual_mov_b32 v42, v0
	s_or_b32 s48, vcc_lo, s48
	s_and_not1_b32 exec_lo, exec_lo, s48
	s_cbranch_execnz .LBB1_8
; %bb.11:                               ; %Flow62
	s_or_b32 exec_lo, exec_lo, s48
.LBB1_12:                               ; %Flow63
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s33
	v_cmp_lt_i64_e64 s0, s[40:41], 1
	v_add_nc_u32_e32 v2, 0x400, v46
	ds_store_b64 v46, v[36:37]
	s_and_b32 vcc_lo, exec_lo, s0
	s_cbranch_vccnz .LBB1_19
; %bb.13:                               ; %.lr.ph
	v_lshlrev_b64 v[5:6], 2, v[44:45]
	v_subrev_nc_u32_e32 v0, 28, v51
	v_cmp_gt_u32_e32 vcc_lo, 4, v50
	v_mov_b32_e32 v1, 0
	v_lshl_add_u32 v3, v33, 2, 0x800
	v_cmp_eq_u32_e64 s0, 0, v50
	s_mov_b32 s5, 0
	v_cndmask_b32_e32 v4, v0, v51, vcc_lo
	v_add_co_u32 v5, vcc_lo, s42, v5
	v_add_co_ci_u32_e32 v6, vcc_lo, s43, v6, vcc_lo
	s_brev_b32 s2, -7
	s_mov_b32 s3, 0x3ffffff
	s_mov_b64 s[6:7], 0
	s_mov_b32 s4, s5
.LBB1_14:                               ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB1_16 Depth 2
	ds_load_b64 v[7:8], v2
	ds_load_b64 v[9:10], v46
	s_add_u32 s1, 0, 0
	s_addc_u32 s8, 0, 0
	v_add_co_u32 v15, s1, 0x3ff, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	s_cmp_lg_u32 s1, 0
	s_addc_u32 s8, s8, 0
	v_readfirstlane_b32 s1, v15
	s_mul_i32 s9, s8, 0x6000000
	s_delay_alu instid0(VALU_DEP_1)
	s_lshl_b32 s11, s1, 22
	s_mul_hi_u32 s12, s1, 0x6000000
	s_mul_i32 s10, s1, 0x6000000
	s_sub_i32 s11, s12, s11
	s_mul_hi_u32 s13, s8, s10
	s_add_i32 s11, s11, s9
	s_waitcnt lgkmcnt(1)
	v_sub_co_u32 v0, vcc_lo, 0xa0000000, v7
	v_sub_co_ci_u32_e32 v13, vcc_lo, 0x3ffffff, v8, vcc_lo
	s_mul_i32 s12, s8, s10
	s_waitcnt lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_2)
	v_mad_u64_u32 v[7:8], null, v0, 6, v[9:10]
	s_mul_hi_u32 s9, s1, s10
	s_mul_hi_u32 s10, s1, s11
	s_mul_i32 s1, s1, s11
	s_mul_hi_u32 s14, s8, s11
	s_add_u32 s1, s9, s1
	s_addc_u32 s9, 0, s10
	s_delay_alu instid0(VALU_DEP_1)
	v_mov_b32_e32 v0, v8
	s_add_u32 s1, s1, s12
	s_mul_i32 s11, s8, s11
	s_addc_u32 s1, s9, s13
	s_addc_u32 s9, s14, 0
	v_mad_u64_u32 v[11:12], null, v13, 6, v[0:1]
	s_add_u32 s1, s1, s11
	s_addc_u32 s9, 0, s9
	v_add_co_u32 v15, s1, v15, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	s_cmp_lg_u32 s1, 0
	s_addc_u32 s1, s8, s9
	v_mov_b32_e32 v8, v11
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[7:8], 3, v[7:8]
	v_lshrrev_b32_e32 v0, 26, v8
	v_and_b32_e32 v8, 0x3ffffff, v8
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshlrev_b64 v[11:12], 29, v[0:1]
	v_lshlrev_b64 v[13:14], 30, v[0:1]
	v_add_co_u32 v0, vcc_lo, v11, v7
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v8, vcc_lo, v12, v8, vcc_lo
	v_add_co_u32 v7, vcc_lo, v0, v13
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v8, vcc_lo, v8, v14, vcc_lo
	v_add_co_u32 v0, vcc_lo, 0x60000000, v7
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v11, vcc_lo, 0xfc000000, v8, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[2:3], v[7:8]
	v_dual_cndmask_b32 v8, v8, v11 :: v_dual_cndmask_b32 v7, v7, v0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mad_u64_u32 v[13:14], null, v8, v15, 0
	v_mad_u64_u32 v[11:12], null, v7, s1, 0
	v_mul_hi_u32 v0, v7, v15
	v_mad_u64_u32 v[15:16], null, v8, s1, 0
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_co_u32 v0, vcc_lo, v0, v11
	v_add_co_ci_u32_e32 v11, vcc_lo, 0, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v13
	v_add_co_ci_u32_e32 v0, vcc_lo, v11, v14, vcc_lo
	v_add_co_ci_u32_e32 v11, vcc_lo, 0, v16, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v15
	v_add_co_ci_u32_e32 v13, vcc_lo, 0, v11, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_mul_lo_u32 v14, 0x3fffff, v0
	v_mad_u64_u32 v[11:12], null, 0xfa000000, v0, 0
	v_mul_lo_u32 v13, 0xfa000000, v13
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_sub_co_u32 v11, vcc_lo, v7, v11
	v_add3_u32 v12, v12, v14, v13
	v_add_co_u32 v14, null, v0, 2
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_sub_nc_u32_e32 v13, v8, v12
	v_subrev_co_ci_u32_e64 v13, s1, 0x3fffff, v13, vcc_lo
	v_subrev_co_u32 v15, s1, 0xfa000000, v11
	v_sub_co_ci_u32_e32 v12, vcc_lo, v8, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_subrev_co_ci_u32_e64 v13, s1, 0, v13, s1
	v_cmp_lt_u32_e32 vcc_lo, 0xf9ffffff, v15
	v_cndmask_b32_e64 v15, 0, -1, vcc_lo
	s_delay_alu instid0(VALU_DEP_3)
	v_cmp_lt_u32_e32 vcc_lo, 0x3ffffe, v13
	v_cndmask_b32_e64 v16, 0, -1, vcc_lo
	v_cmp_lt_u32_e32 vcc_lo, 0xf9ffffff, v11
	v_cndmask_b32_e64 v11, 0, -1, vcc_lo
	v_cmp_lt_u32_e32 vcc_lo, 0x3ffffe, v12
	v_cndmask_b32_e64 v17, 0, -1, vcc_lo
	v_cmp_eq_u32_e32 vcc_lo, 0x3fffff, v13
	v_cndmask_b32_e32 v13, v16, v15, vcc_lo
	v_cmp_eq_u32_e32 vcc_lo, 0x3fffff, v12
	v_add_co_u32 v15, null, v0, 1
	v_cndmask_b32_e32 v11, v17, v11, vcc_lo
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cmp_ne_u32_e32 vcc_lo, 0, v13
	v_cndmask_b32_e32 v12, v15, v14, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cmp_ne_u32_e32 vcc_lo, 0, v11
	v_cndmask_b32_e32 v0, v0, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_1)
	v_lshlrev_b64 v[11:12], v4, v[0:1]
	ds_store_b64 v2, v[9:10]
	ds_store_b64 v46, v[7:8]
	ds_store_b32 v3, v11
	s_waitcnt lgkmcnt(0)
	s_waitcnt_vscnt null, 0x0
	s_barrier
	buffer_gl0_inv
	s_and_saveexec_b32 s1, s0
	s_cbranch_execz .LBB1_18
; %bb.15:                               ; %.preheader.preheader
                                        ;   in Loop: Header=BB1_14 Depth=1
	v_mov_b32_e32 v0, 0
	s_mov_b32 s8, 0
.LBB1_16:                               ; %.preheader
                                        ;   Parent Loop BB1_14 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_add_nc_u32_e32 v7, s8, v3
	s_add_i32 s8, s8, 4
	s_cmp_lg_u32 s8, 32
	ds_load_b32 v7, v7
	s_waitcnt lgkmcnt(0)
	v_add_nc_u32_e32 v0, v7, v0
	s_cbranch_scc1 .LBB1_16
; %bb.17:                               ;   in Loop: Header=BB1_14 Depth=1
	s_lshl_b64 s[6:7], s[6:7], 2
	s_delay_alu instid0(SALU_CYCLE_1)
	v_add_co_u32 v7, vcc_lo, v5, s6
	v_add_co_ci_u32_e32 v8, vcc_lo, s7, v6, vcc_lo
	global_store_b32 v[7:8], v0, off
.LBB1_18:                               ; %Flow
                                        ;   in Loop: Header=BB1_14 Depth=1
	s_or_b32 exec_lo, exec_lo, s1
	global_load_b64 v[7:8], v1, s[44:45]
	s_add_i32 s4, s4, 1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_mov_b64 s[6:7], s[4:5]
	s_waitcnt vmcnt(0)
	v_cmp_lt_i64_e32 vcc_lo, s[4:5], v[7:8]
	s_cbranch_vccnz .LBB1_14
.LBB1_19:                               ; %._crit_edge
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
		.amdhsa_group_segment_fixed_size 2560
		.amdhsa_private_segment_fixed_size 8
		.amdhsa_kernarg_size 280
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 1
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 52
		.amdhsa_next_free_sgpr 54
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end1:
	.size	_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl, .Lfunc_end1-_Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 1880
; NumSgprs: 56
; NumVgprs: 52
; ScratchSize: 8
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 2560 bytes/workgroup (compile time only)
; SGPRBlocks: 6
; VGPRBlocks: 6
; NumSGPRsForWavesPerEU: 56
; NumVGPRsForWavesPerEU: 52
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 1
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.protected	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl ; -- Begin function _Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.globl	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
	.p2align	8
	.type	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl,@function
_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl: ; @_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
; %bb.0:
	s_clause 0x1
	s_load_b128 s[40:43], s[0:1], 0x0
	s_load_b64 s[44:45], s[0:1], 0x10
	v_mov_b32_e32 v33, v0
	s_mov_b32 s33, exec_lo
	s_mov_b32 s32, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_and_b32_e32 v50, 7, v33
	v_lshlrev_b32_e32 v51, 3, v50
	s_waitcnt lgkmcnt(0)
	s_clause 0x1
	global_load_b64 v[36:37], v51, s[40:41] offset:64
	global_load_b64 v[34:35], v51, s[40:41]
	s_load_b32 s0, s[0:1], 0x24
	s_load_b64 s[40:41], s[44:45], 0x0
	s_waitcnt lgkmcnt(0)
	s_and_b32 s0, s0, 0xffff
	s_waitcnt vmcnt(1)
	v_dual_mov_b32 v41, v37 :: v_dual_mov_b32 v40, v36
	s_waitcnt vmcnt(0)
	v_mad_u64_u32 v[0:1], null, s15, s0, v[33:34]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshrrev_b32_e32 v3, 3, v0
	v_mad_u64_u32 v[44:45], null, s40, v3, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v0, v45
	v_mad_u64_u32 v[1:2], null, s41, v3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v45, v1
	v_cmpx_ne_u64_e32 0, v[44:45]
	s_cbranch_execz .LBB2_6
; %bb.1:                                ; %.lr.ph.i.preheader
	v_mov_b32_e32 v39, v35
	v_mov_b32_e32 v41, v37
	v_dual_mov_b32 v49, v45 :: v_dual_mov_b32 v48, v44
	v_dual_mov_b32 v47, 0 :: v_dual_mov_b32 v38, v34
	v_mov_b32_e32 v40, v36
	s_brev_b32 s46, -7
	s_mov_b32 s47, 0x3ffffff
	s_mov_b32 s48, 0
	s_mov_b32 s49, 0
	s_getpc_b64 s[52:53]
	s_add_u32 s52, s52, _Z15gq58x4_GetNextNyyj@rel32@lo+4
	s_addc_u32 s53, s53, _Z15gq58x4_GetNextNyyj@rel32@hi+12
.LBB2_2:                                ; %.lr.ph.i
                                        ; =>This Inner Loop Header: Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_and_b32_e32 v0, 1, v48
	s_mov_b32 s50, exec_lo
	v_cmpx_eq_u32_e32 1, v0
	s_cbranch_execz .LBB2_4
; %bb.3:                                ;   in Loop: Header=BB2_2 Depth=1
	v_dual_mov_b32 v0, v40 :: v_dual_mov_b32 v1, v41
	v_dual_mov_b32 v2, v38 :: v_dual_mov_b32 v3, v39
	v_mov_b32_e32 v4, s49
	s_swappc_b64 s[30:31], s[52:53]
	v_sub_co_u32 v2, vcc_lo, 0xa0000000, v40
	v_dual_mov_b32 v42, v0 :: v_dual_mov_b32 v43, v1
	v_sub_co_ci_u32_e32 v4, vcc_lo, 0x3ffffff, v41, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[0:1], null, v2, 6, v[38:39]
	v_mad_u64_u32 v[2:3], null, v4, 6, v[1:2]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v1, v2
	v_lshlrev_b64 v[0:1], 3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshrrev_b32_e32 v46, 26, v1
	v_and_b32_e32 v1, 0x3ffffff, v1
	v_lshlrev_b64 v[2:3], 29, v[46:47]
	v_lshlrev_b64 v[4:5], 30, v[46:47]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v2, v0
	v_add_co_ci_u32_e32 v1, vcc_lo, v3, v1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v4
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v5, vcc_lo
	v_mov_b32_e32 v4, s49
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v2, vcc_lo, 0x60000000, v0
	v_add_co_ci_u32_e32 v3, vcc_lo, 0xfc000000, v1, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[46:47], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v2, v0, v2, vcc_lo
	v_dual_mov_b32 v0, v38 :: v_dual_cndmask_b32 v3, v1, v3
	v_mov_b32_e32 v1, v39
	s_swappc_b64 s[30:31], s[52:53]
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v38, v0 :: v_dual_mov_b32 v39, v1
	v_dual_mov_b32 v40, v42 :: v_dual_mov_b32 v41, v43
.LBB2_4:                                ;   in Loop: Header=BB2_2 Depth=1
	s_or_b32 exec_lo, exec_lo, s50
	v_lshrrev_b64 v[0:1], 1, v[48:49]
	v_cmp_gt_u64_e32 vcc_lo, 2, v[48:49]
	s_add_i32 s49, s49, 1
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_dual_mov_b32 v49, v1 :: v_dual_mov_b32 v48, v0
	s_or_b32 s48, vcc_lo, s48
	s_and_not1_b32 exec_lo, exec_lo, s48
	s_cbranch_execnz .LBB2_2
; %bb.5:                                ; %Flow64
	s_or_b32 exec_lo, exec_lo, s48
.LBB2_6:                                ; %Flow65
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s33
	v_add_co_u32 v42, vcc_lo, v44, 1
	v_add_co_ci_u32_e32 v43, vcc_lo, 0, v45, vcc_lo
	v_lshlrev_b32_e32 v46, 3, v33
	s_mov_b32 s33, exec_lo
	ds_store_b64 v46, v[40:41] offset:1024
	v_cmpx_ne_u64_e32 0, v[42:43]
	s_cbranch_execz .LBB2_12
; %bb.7:                                ; %.lr.ph.i37.preheader
	v_mov_b32_e32 v41, 0
	s_brev_b32 s46, -7
	s_mov_b32 s47, 0x3ffffff
	s_mov_b32 s48, 0
	s_mov_b32 s49, 0
	s_getpc_b64 s[52:53]
	s_add_u32 s52, s52, _Z15gq58x4_GetNextNyyj@rel32@lo+4
	s_addc_u32 s53, s53, _Z15gq58x4_GetNextNyyj@rel32@hi+12
.LBB2_8:                                ; %.lr.ph.i37
                                        ; =>This Inner Loop Header: Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_and_b32_e32 v0, 1, v42
	s_mov_b32 s50, exec_lo
	v_cmpx_eq_u32_e32 1, v0
	s_cbranch_execz .LBB2_10
; %bb.9:                                ;   in Loop: Header=BB2_8 Depth=1
	v_dual_mov_b32 v0, v36 :: v_dual_mov_b32 v1, v37
	v_dual_mov_b32 v2, v34 :: v_dual_mov_b32 v3, v35
	v_mov_b32_e32 v4, s49
	s_swappc_b64 s[30:31], s[52:53]
	v_sub_co_u32 v2, vcc_lo, 0xa0000000, v36
	v_dual_mov_b32 v38, v0 :: v_dual_mov_b32 v39, v1
	v_sub_co_ci_u32_e32 v4, vcc_lo, 0x3ffffff, v37, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[0:1], null, v2, 6, v[34:35]
	v_mad_u64_u32 v[2:3], null, v4, 6, v[1:2]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v1, v2
	v_lshlrev_b64 v[0:1], 3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshrrev_b32_e32 v40, 26, v1
	v_and_b32_e32 v1, 0x3ffffff, v1
	v_lshlrev_b64 v[2:3], 29, v[40:41]
	v_lshlrev_b64 v[4:5], 30, v[40:41]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v2, v0
	v_add_co_ci_u32_e32 v1, vcc_lo, v3, v1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v4
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v5, vcc_lo
	v_mov_b32_e32 v4, s49
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v2, vcc_lo, 0x60000000, v0
	v_add_co_ci_u32_e32 v3, vcc_lo, 0xfc000000, v1, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[46:47], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v2, v0, v2, vcc_lo
	v_dual_mov_b32 v0, v34 :: v_dual_cndmask_b32 v3, v1, v3
	v_mov_b32_e32 v1, v35
	s_swappc_b64 s[30:31], s[52:53]
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v34, v0 :: v_dual_mov_b32 v35, v1
	v_dual_mov_b32 v36, v38 :: v_dual_mov_b32 v37, v39
.LBB2_10:                               ;   in Loop: Header=BB2_8 Depth=1
	s_or_b32 exec_lo, exec_lo, s50
	v_lshrrev_b64 v[0:1], 1, v[42:43]
	v_cmp_gt_u64_e32 vcc_lo, 2, v[42:43]
	s_add_i32 s49, s49, 1
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_dual_mov_b32 v43, v1 :: v_dual_mov_b32 v42, v0
	s_or_b32 s48, vcc_lo, s48
	s_and_not1_b32 exec_lo, exec_lo, s48
	s_cbranch_execnz .LBB2_8
; %bb.11:                               ; %Flow62
	s_or_b32 exec_lo, exec_lo, s48
.LBB2_12:                               ; %Flow63
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s33
	v_cmp_lt_i64_e64 s0, s[40:41], 1
	v_add_nc_u32_e32 v2, 0x400, v46
	ds_store_b64 v46, v[36:37]
	s_and_b32 vcc_lo, exec_lo, s0
	s_cbranch_vccnz .LBB2_19
; %bb.13:                               ; %.lr.ph
	v_lshlrev_b64 v[5:6], 2, v[44:45]
	v_subrev_nc_u32_e32 v0, 28, v51
	v_cmp_gt_u32_e32 vcc_lo, 4, v50
	v_mov_b32_e32 v1, 0
	v_lshl_add_u32 v3, v33, 2, 0x800
	v_cmp_eq_u32_e64 s0, 0, v50
	s_mov_b32 s5, 0
	v_cndmask_b32_e32 v4, v0, v51, vcc_lo
	v_add_co_u32 v5, vcc_lo, s42, v5
	v_add_co_ci_u32_e32 v6, vcc_lo, s43, v6, vcc_lo
	s_brev_b32 s2, -7
	s_mov_b32 s3, 0x3ffffff
	s_mov_b64 s[6:7], 0
	s_mov_b32 s4, s5
.LBB2_14:                               ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB2_16 Depth 2
	ds_load_b64 v[7:8], v2
	ds_load_b64 v[9:10], v46
	s_add_u32 s1, 0, 0
	s_addc_u32 s8, 0, 0
	v_add_co_u32 v15, s1, 0x3ff, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	s_cmp_lg_u32 s1, 0
	s_addc_u32 s8, s8, 0
	v_readfirstlane_b32 s1, v15
	s_mul_i32 s9, s8, 0x6000000
	s_delay_alu instid0(VALU_DEP_1)
	s_lshl_b32 s11, s1, 22
	s_mul_hi_u32 s12, s1, 0x6000000
	s_mul_i32 s10, s1, 0x6000000
	s_sub_i32 s11, s12, s11
	s_mul_hi_u32 s13, s8, s10
	s_add_i32 s11, s11, s9
	s_waitcnt lgkmcnt(1)
	v_sub_co_u32 v0, vcc_lo, 0xa0000000, v7
	v_sub_co_ci_u32_e32 v13, vcc_lo, 0x3ffffff, v8, vcc_lo
	s_mul_i32 s12, s8, s10
	s_waitcnt lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_2)
	v_mad_u64_u32 v[7:8], null, v0, 6, v[9:10]
	s_mul_hi_u32 s9, s1, s10
	s_mul_hi_u32 s10, s1, s11
	s_mul_i32 s1, s1, s11
	s_mul_hi_u32 s14, s8, s11
	s_add_u32 s1, s9, s1
	s_addc_u32 s9, 0, s10
	s_delay_alu instid0(VALU_DEP_1)
	v_mov_b32_e32 v0, v8
	s_add_u32 s1, s1, s12
	s_mul_i32 s11, s8, s11
	s_addc_u32 s1, s9, s13
	s_addc_u32 s9, s14, 0
	v_mad_u64_u32 v[11:12], null, v13, 6, v[0:1]
	s_add_u32 s1, s1, s11
	s_addc_u32 s9, 0, s9
	v_add_co_u32 v15, s1, v15, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	s_cmp_lg_u32 s1, 0
	s_addc_u32 s1, s8, s9
	v_mov_b32_e32 v8, v11
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[7:8], 3, v[7:8]
	v_lshrrev_b32_e32 v0, 26, v8
	v_and_b32_e32 v8, 0x3ffffff, v8
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshlrev_b64 v[11:12], 29, v[0:1]
	v_lshlrev_b64 v[13:14], 30, v[0:1]
	v_add_co_u32 v0, vcc_lo, v11, v7
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v8, vcc_lo, v12, v8, vcc_lo
	v_add_co_u32 v7, vcc_lo, v0, v13
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v8, vcc_lo, v8, v14, vcc_lo
	v_add_co_u32 v0, vcc_lo, 0x60000000, v7
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v11, vcc_lo, 0xfc000000, v8, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[2:3], v[7:8]
	v_dual_cndmask_b32 v8, v8, v11 :: v_dual_cndmask_b32 v7, v7, v0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mad_u64_u32 v[13:14], null, v8, v15, 0
	v_mad_u64_u32 v[11:12], null, v7, s1, 0
	v_mul_hi_u32 v0, v7, v15
	v_mad_u64_u32 v[15:16], null, v8, s1, 0
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_co_u32 v0, vcc_lo, v0, v11
	v_add_co_ci_u32_e32 v11, vcc_lo, 0, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v13
	v_add_co_ci_u32_e32 v0, vcc_lo, v11, v14, vcc_lo
	v_add_co_ci_u32_e32 v11, vcc_lo, 0, v16, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v15
	v_add_co_ci_u32_e32 v13, vcc_lo, 0, v11, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_mul_lo_u32 v14, 0x3fffff, v0
	v_mad_u64_u32 v[11:12], null, 0xfa000000, v0, 0
	v_mul_lo_u32 v13, 0xfa000000, v13
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_sub_co_u32 v11, vcc_lo, v7, v11
	v_add3_u32 v12, v12, v14, v13
	v_add_co_u32 v14, null, v0, 2
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_sub_nc_u32_e32 v13, v8, v12
	v_subrev_co_ci_u32_e64 v13, s1, 0x3fffff, v13, vcc_lo
	v_subrev_co_u32 v15, s1, 0xfa000000, v11
	v_sub_co_ci_u32_e32 v12, vcc_lo, v8, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_subrev_co_ci_u32_e64 v13, s1, 0, v13, s1
	v_cmp_lt_u32_e32 vcc_lo, 0xf9ffffff, v15
	v_cndmask_b32_e64 v15, 0, -1, vcc_lo
	s_delay_alu instid0(VALU_DEP_3)
	v_cmp_lt_u32_e32 vcc_lo, 0x3ffffe, v13
	v_cndmask_b32_e64 v16, 0, -1, vcc_lo
	v_cmp_lt_u32_e32 vcc_lo, 0xf9ffffff, v11
	v_cndmask_b32_e64 v11, 0, -1, vcc_lo
	v_cmp_lt_u32_e32 vcc_lo, 0x3ffffe, v12
	v_cndmask_b32_e64 v17, 0, -1, vcc_lo
	v_cmp_eq_u32_e32 vcc_lo, 0x3fffff, v13
	v_cndmask_b32_e32 v13, v16, v15, vcc_lo
	v_cmp_eq_u32_e32 vcc_lo, 0x3fffff, v12
	v_add_co_u32 v15, null, v0, 1
	v_cndmask_b32_e32 v11, v17, v11, vcc_lo
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cmp_ne_u32_e32 vcc_lo, 0, v13
	v_cndmask_b32_e32 v12, v15, v14, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cmp_ne_u32_e32 vcc_lo, 0, v11
	v_cndmask_b32_e32 v0, v0, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_1)
	v_lshlrev_b64 v[11:12], v4, v[0:1]
	ds_store_b64 v2, v[9:10]
	ds_store_b64 v46, v[7:8]
	ds_store_b32 v3, v11
	s_waitcnt lgkmcnt(0)
	s_waitcnt_vscnt null, 0x0
	s_barrier
	buffer_gl0_inv
	s_and_saveexec_b32 s1, s0
	s_cbranch_execz .LBB2_18
; %bb.15:                               ; %.preheader.preheader
                                        ;   in Loop: Header=BB2_14 Depth=1
	v_mov_b32_e32 v0, 0
	s_mov_b32 s8, 0
.LBB2_16:                               ; %.preheader
                                        ;   Parent Loop BB2_14 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_add_nc_u32_e32 v7, s8, v3
	s_add_i32 s8, s8, 4
	s_cmp_lg_u32 s8, 32
	ds_load_b32 v7, v7
	s_waitcnt lgkmcnt(0)
	v_add_nc_u32_e32 v0, v7, v0
	s_cbranch_scc1 .LBB2_16
; %bb.17:                               ;   in Loop: Header=BB2_14 Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_cvt_f32_u32_e32 v0, v0
	s_lshl_b64 s[6:7], s[6:7], 2
	v_add_co_u32 v7, vcc_lo, v5, s6
	s_delay_alu instid0(VALU_DEP_2)
	v_mul_f32_e32 v0, 0x2f800000, v0
	v_add_co_ci_u32_e32 v8, vcc_lo, s7, v6, vcc_lo
	global_store_b32 v[7:8], v0, off
.LBB2_18:                               ; %Flow
                                        ;   in Loop: Header=BB2_14 Depth=1
	s_or_b32 exec_lo, exec_lo, s1
	global_load_b64 v[7:8], v1, s[44:45]
	s_add_i32 s4, s4, 1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_mov_b64 s[6:7], s[4:5]
	s_waitcnt vmcnt(0)
	v_cmp_lt_i64_e32 vcc_lo, s[4:5], v[7:8]
	s_cbranch_vccnz .LBB2_14
.LBB2_19:                               ; %._crit_edge
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
		.amdhsa_group_segment_fixed_size 2560
		.amdhsa_private_segment_fixed_size 8
		.amdhsa_kernarg_size 280
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 1
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 52
		.amdhsa_next_free_sgpr 54
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end2:
	.size	_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl, .Lfunc_end2-_Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 1896
; NumSgprs: 56
; NumVgprs: 52
; ScratchSize: 8
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 2560 bytes/workgroup (compile time only)
; SGPRBlocks: 6
; VGPRBlocks: 6
; NumSGPRsForWavesPerEU: 56
; NumVGPRsForWavesPerEU: 52
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 1
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.protected	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl ; -- Begin function _Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.globl	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
	.p2align	8
	.type	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl,@function
_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl: ; @_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
; %bb.0:
	s_clause 0x1
	s_load_b128 s[40:43], s[0:1], 0x0
	s_load_b64 s[44:45], s[0:1], 0x10
	v_mov_b32_e32 v33, v0
	s_mov_b32 s33, exec_lo
	s_mov_b32 s32, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_and_b32_e32 v50, 7, v33
	v_lshlrev_b32_e32 v51, 3, v50
	s_waitcnt lgkmcnt(0)
	s_clause 0x1
	global_load_b64 v[36:37], v51, s[40:41] offset:64
	global_load_b64 v[34:35], v51, s[40:41]
	s_load_b32 s0, s[0:1], 0x24
	s_load_b64 s[40:41], s[44:45], 0x0
	s_waitcnt lgkmcnt(0)
	s_and_b32 s0, s0, 0xffff
	s_waitcnt vmcnt(1)
	v_dual_mov_b32 v41, v37 :: v_dual_mov_b32 v40, v36
	s_waitcnt vmcnt(0)
	v_mad_u64_u32 v[0:1], null, s15, s0, v[33:34]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshrrev_b32_e32 v3, 3, v0
	v_mad_u64_u32 v[44:45], null, s40, v3, 0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v0, v45
	v_mad_u64_u32 v[1:2], null, s41, v3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v45, v1
	v_cmpx_ne_u64_e32 0, v[44:45]
	s_cbranch_execz .LBB3_6
; %bb.1:                                ; %.lr.ph.i.preheader
	v_mov_b32_e32 v39, v35
	v_mov_b32_e32 v41, v37
	v_dual_mov_b32 v49, v45 :: v_dual_mov_b32 v48, v44
	v_dual_mov_b32 v47, 0 :: v_dual_mov_b32 v38, v34
	v_mov_b32_e32 v40, v36
	s_brev_b32 s46, -7
	s_mov_b32 s47, 0x3ffffff
	s_mov_b32 s48, 0
	s_mov_b32 s49, 0
	s_getpc_b64 s[52:53]
	s_add_u32 s52, s52, _Z15gq58x4_GetNextNyyj@rel32@lo+4
	s_addc_u32 s53, s53, _Z15gq58x4_GetNextNyyj@rel32@hi+12
.LBB3_2:                                ; %.lr.ph.i
                                        ; =>This Inner Loop Header: Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_and_b32_e32 v0, 1, v48
	s_mov_b32 s50, exec_lo
	v_cmpx_eq_u32_e32 1, v0
	s_cbranch_execz .LBB3_4
; %bb.3:                                ;   in Loop: Header=BB3_2 Depth=1
	v_dual_mov_b32 v0, v40 :: v_dual_mov_b32 v1, v41
	v_dual_mov_b32 v2, v38 :: v_dual_mov_b32 v3, v39
	v_mov_b32_e32 v4, s49
	s_swappc_b64 s[30:31], s[52:53]
	v_sub_co_u32 v2, vcc_lo, 0xa0000000, v40
	v_dual_mov_b32 v42, v0 :: v_dual_mov_b32 v43, v1
	v_sub_co_ci_u32_e32 v4, vcc_lo, 0x3ffffff, v41, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[0:1], null, v2, 6, v[38:39]
	v_mad_u64_u32 v[2:3], null, v4, 6, v[1:2]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v1, v2
	v_lshlrev_b64 v[0:1], 3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshrrev_b32_e32 v46, 26, v1
	v_and_b32_e32 v1, 0x3ffffff, v1
	v_lshlrev_b64 v[2:3], 29, v[46:47]
	v_lshlrev_b64 v[4:5], 30, v[46:47]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v2, v0
	v_add_co_ci_u32_e32 v1, vcc_lo, v3, v1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v4
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v5, vcc_lo
	v_mov_b32_e32 v4, s49
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v2, vcc_lo, 0x60000000, v0
	v_add_co_ci_u32_e32 v3, vcc_lo, 0xfc000000, v1, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[46:47], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v2, v0, v2, vcc_lo
	v_dual_mov_b32 v0, v38 :: v_dual_cndmask_b32 v3, v1, v3
	v_mov_b32_e32 v1, v39
	s_swappc_b64 s[30:31], s[52:53]
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v38, v0 :: v_dual_mov_b32 v39, v1
	v_dual_mov_b32 v40, v42 :: v_dual_mov_b32 v41, v43
.LBB3_4:                                ;   in Loop: Header=BB3_2 Depth=1
	s_or_b32 exec_lo, exec_lo, s50
	v_lshrrev_b64 v[0:1], 1, v[48:49]
	v_cmp_gt_u64_e32 vcc_lo, 2, v[48:49]
	s_add_i32 s49, s49, 1
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_dual_mov_b32 v49, v1 :: v_dual_mov_b32 v48, v0
	s_or_b32 s48, vcc_lo, s48
	s_and_not1_b32 exec_lo, exec_lo, s48
	s_cbranch_execnz .LBB3_2
; %bb.5:                                ; %Flow64
	s_or_b32 exec_lo, exec_lo, s48
.LBB3_6:                                ; %Flow65
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s33
	v_add_co_u32 v42, vcc_lo, v44, 1
	v_add_co_ci_u32_e32 v43, vcc_lo, 0, v45, vcc_lo
	v_lshlrev_b32_e32 v46, 3, v33
	s_mov_b32 s33, exec_lo
	ds_store_b64 v46, v[40:41] offset:1024
	v_cmpx_ne_u64_e32 0, v[42:43]
	s_cbranch_execz .LBB3_12
; %bb.7:                                ; %.lr.ph.i37.preheader
	v_mov_b32_e32 v41, 0
	s_brev_b32 s46, -7
	s_mov_b32 s47, 0x3ffffff
	s_mov_b32 s48, 0
	s_mov_b32 s49, 0
	s_getpc_b64 s[52:53]
	s_add_u32 s52, s52, _Z15gq58x4_GetNextNyyj@rel32@lo+4
	s_addc_u32 s53, s53, _Z15gq58x4_GetNextNyyj@rel32@hi+12
.LBB3_8:                                ; %.lr.ph.i37
                                        ; =>This Inner Loop Header: Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_and_b32_e32 v0, 1, v42
	s_mov_b32 s50, exec_lo
	v_cmpx_eq_u32_e32 1, v0
	s_cbranch_execz .LBB3_10
; %bb.9:                                ;   in Loop: Header=BB3_8 Depth=1
	v_dual_mov_b32 v0, v36 :: v_dual_mov_b32 v1, v37
	v_dual_mov_b32 v2, v34 :: v_dual_mov_b32 v3, v35
	v_mov_b32_e32 v4, s49
	s_swappc_b64 s[30:31], s[52:53]
	v_sub_co_u32 v2, vcc_lo, 0xa0000000, v36
	v_dual_mov_b32 v38, v0 :: v_dual_mov_b32 v39, v1
	v_sub_co_ci_u32_e32 v4, vcc_lo, 0x3ffffff, v37, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[0:1], null, v2, 6, v[34:35]
	v_mad_u64_u32 v[2:3], null, v4, 6, v[1:2]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mov_b32_e32 v1, v2
	v_lshlrev_b64 v[0:1], 3, v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshrrev_b32_e32 v40, 26, v1
	v_and_b32_e32 v1, 0x3ffffff, v1
	v_lshlrev_b64 v[2:3], 29, v[40:41]
	v_lshlrev_b64 v[4:5], 30, v[40:41]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v2, v0
	v_add_co_ci_u32_e32 v1, vcc_lo, v3, v1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v4
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v5, vcc_lo
	v_mov_b32_e32 v4, s49
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v2, vcc_lo, 0x60000000, v0
	v_add_co_ci_u32_e32 v3, vcc_lo, 0xfc000000, v1, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[46:47], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v2, v0, v2, vcc_lo
	v_dual_mov_b32 v0, v34 :: v_dual_cndmask_b32 v3, v1, v3
	v_mov_b32_e32 v1, v35
	s_swappc_b64 s[30:31], s[52:53]
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v34, v0 :: v_dual_mov_b32 v35, v1
	v_dual_mov_b32 v36, v38 :: v_dual_mov_b32 v37, v39
.LBB3_10:                               ;   in Loop: Header=BB3_8 Depth=1
	s_or_b32 exec_lo, exec_lo, s50
	v_lshrrev_b64 v[0:1], 1, v[42:43]
	v_cmp_gt_u64_e32 vcc_lo, 2, v[42:43]
	s_add_i32 s49, s49, 1
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_dual_mov_b32 v43, v1 :: v_dual_mov_b32 v42, v0
	s_or_b32 s48, vcc_lo, s48
	s_and_not1_b32 exec_lo, exec_lo, s48
	s_cbranch_execnz .LBB3_8
; %bb.11:                               ; %Flow62
	s_or_b32 exec_lo, exec_lo, s48
.LBB3_12:                               ; %Flow63
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s33
	v_cmp_lt_i64_e64 s0, s[40:41], 1
	v_add_nc_u32_e32 v2, 0x400, v46
	ds_store_b64 v46, v[36:37]
	s_and_b32 vcc_lo, exec_lo, s0
	s_cbranch_vccnz .LBB3_19
; %bb.13:                               ; %.lr.ph
	v_lshlrev_b64 v[5:6], 3, v[44:45]
	v_subrev_nc_u32_e32 v0, 28, v51
	v_cmp_gt_u32_e32 vcc_lo, 4, v50
	v_mov_b32_e32 v1, 0
	v_lshl_add_u32 v3, v33, 2, 0x800
	v_cmp_eq_u32_e64 s0, 0, v50
	s_mov_b32 s5, 0
	v_cndmask_b32_e32 v4, v0, v51, vcc_lo
	v_add_co_u32 v5, vcc_lo, s42, v5
	v_add_co_ci_u32_e32 v6, vcc_lo, s43, v6, vcc_lo
	s_brev_b32 s2, -7
	s_mov_b32 s3, 0x3ffffff
	s_mov_b64 s[6:7], 0
	s_mov_b32 s4, s5
.LBB3_14:                               ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB3_16 Depth 2
	ds_load_b64 v[7:8], v2
	ds_load_b64 v[9:10], v46
	s_add_u32 s1, 0, 0
	s_addc_u32 s8, 0, 0
	v_add_co_u32 v15, s1, 0x3ff, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	s_cmp_lg_u32 s1, 0
	s_addc_u32 s8, s8, 0
	v_readfirstlane_b32 s1, v15
	s_mul_i32 s9, s8, 0x6000000
	s_delay_alu instid0(VALU_DEP_1)
	s_lshl_b32 s11, s1, 22
	s_mul_hi_u32 s12, s1, 0x6000000
	s_mul_i32 s10, s1, 0x6000000
	s_sub_i32 s11, s12, s11
	s_mul_hi_u32 s13, s8, s10
	s_add_i32 s11, s11, s9
	s_waitcnt lgkmcnt(1)
	v_sub_co_u32 v0, vcc_lo, 0xa0000000, v7
	v_sub_co_ci_u32_e32 v13, vcc_lo, 0x3ffffff, v8, vcc_lo
	s_mul_i32 s12, s8, s10
	s_waitcnt lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_2)
	v_mad_u64_u32 v[7:8], null, v0, 6, v[9:10]
	s_mul_hi_u32 s9, s1, s10
	s_mul_hi_u32 s10, s1, s11
	s_mul_i32 s1, s1, s11
	s_mul_hi_u32 s14, s8, s11
	s_add_u32 s1, s9, s1
	s_addc_u32 s9, 0, s10
	s_delay_alu instid0(VALU_DEP_1)
	v_mov_b32_e32 v0, v8
	s_add_u32 s1, s1, s12
	s_mul_i32 s11, s8, s11
	s_addc_u32 s1, s9, s13
	s_addc_u32 s9, s14, 0
	v_mad_u64_u32 v[11:12], null, v13, 6, v[0:1]
	s_add_u32 s1, s1, s11
	s_addc_u32 s9, 0, s9
	v_add_co_u32 v15, s1, v15, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	s_cmp_lg_u32 s1, 0
	s_addc_u32 s1, s8, s9
	v_mov_b32_e32 v8, v11
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[7:8], 3, v[7:8]
	v_lshrrev_b32_e32 v0, 26, v8
	v_and_b32_e32 v8, 0x3ffffff, v8
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_lshlrev_b64 v[11:12], 29, v[0:1]
	v_lshlrev_b64 v[13:14], 30, v[0:1]
	v_add_co_u32 v0, vcc_lo, v11, v7
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v8, vcc_lo, v12, v8, vcc_lo
	v_add_co_u32 v7, vcc_lo, v0, v13
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v8, vcc_lo, v8, v14, vcc_lo
	v_add_co_u32 v0, vcc_lo, 0x60000000, v7
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_co_ci_u32_e32 v11, vcc_lo, 0xfc000000, v8, vcc_lo
	v_cmp_lt_u64_e32 vcc_lo, s[2:3], v[7:8]
	v_dual_cndmask_b32 v8, v8, v11 :: v_dual_cndmask_b32 v7, v7, v0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mad_u64_u32 v[13:14], null, v8, v15, 0
	v_mad_u64_u32 v[11:12], null, v7, s1, 0
	v_mul_hi_u32 v0, v7, v15
	v_mad_u64_u32 v[15:16], null, v8, s1, 0
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_co_u32 v0, vcc_lo, v0, v11
	v_add_co_ci_u32_e32 v11, vcc_lo, 0, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v13
	v_add_co_ci_u32_e32 v0, vcc_lo, v11, v14, vcc_lo
	v_add_co_ci_u32_e32 v11, vcc_lo, 0, v16, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v0, vcc_lo, v0, v15
	v_add_co_ci_u32_e32 v13, vcc_lo, 0, v11, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_mul_lo_u32 v14, 0x3fffff, v0
	v_mad_u64_u32 v[11:12], null, 0xfa000000, v0, 0
	v_mul_lo_u32 v13, 0xfa000000, v13
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_sub_co_u32 v11, vcc_lo, v7, v11
	v_add3_u32 v12, v12, v14, v13
	v_add_co_u32 v14, null, v0, 2
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_sub_nc_u32_e32 v13, v8, v12
	v_subrev_co_ci_u32_e64 v13, s1, 0x3fffff, v13, vcc_lo
	v_subrev_co_u32 v15, s1, 0xfa000000, v11
	v_sub_co_ci_u32_e32 v12, vcc_lo, v8, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_subrev_co_ci_u32_e64 v13, s1, 0, v13, s1
	v_cmp_lt_u32_e32 vcc_lo, 0xf9ffffff, v15
	v_cndmask_b32_e64 v15, 0, -1, vcc_lo
	s_delay_alu instid0(VALU_DEP_3)
	v_cmp_lt_u32_e32 vcc_lo, 0x3ffffe, v13
	v_cndmask_b32_e64 v16, 0, -1, vcc_lo
	v_cmp_lt_u32_e32 vcc_lo, 0xf9ffffff, v11
	v_cndmask_b32_e64 v11, 0, -1, vcc_lo
	v_cmp_lt_u32_e32 vcc_lo, 0x3ffffe, v12
	v_cndmask_b32_e64 v17, 0, -1, vcc_lo
	v_cmp_eq_u32_e32 vcc_lo, 0x3fffff, v13
	v_cndmask_b32_e32 v13, v16, v15, vcc_lo
	v_cmp_eq_u32_e32 vcc_lo, 0x3fffff, v12
	v_add_co_u32 v15, null, v0, 1
	v_cndmask_b32_e32 v11, v17, v11, vcc_lo
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cmp_ne_u32_e32 vcc_lo, 0, v13
	v_cndmask_b32_e32 v12, v15, v14, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cmp_ne_u32_e32 vcc_lo, 0, v11
	v_cndmask_b32_e32 v0, v0, v12, vcc_lo
	s_delay_alu instid0(VALU_DEP_1)
	v_lshlrev_b64 v[11:12], v4, v[0:1]
	ds_store_b64 v2, v[9:10]
	ds_store_b64 v46, v[7:8]
	ds_store_b32 v3, v11
	s_waitcnt lgkmcnt(0)
	s_waitcnt_vscnt null, 0x0
	s_barrier
	buffer_gl0_inv
	s_and_saveexec_b32 s1, s0
	s_cbranch_execz .LBB3_18
; %bb.15:                               ; %.preheader.preheader
                                        ;   in Loop: Header=BB3_14 Depth=1
	v_mov_b32_e32 v0, 0
	s_mov_b32 s8, 0
.LBB3_16:                               ; %.preheader
                                        ;   Parent Loop BB3_14 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_add_nc_u32_e32 v7, s8, v3
	s_add_i32 s8, s8, 4
	s_cmp_lg_u32 s8, 32
	ds_load_b32 v7, v7
	s_waitcnt lgkmcnt(0)
	v_add_nc_u32_e32 v0, v7, v0
	s_cbranch_scc1 .LBB3_16
; %bb.17:                               ;   in Loop: Header=BB3_14 Depth=1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(SALU_CYCLE_1)
	v_cvt_f64_u32_e32 v[7:8], v0
	s_lshl_b64 s[6:7], s[6:7], 3
	v_add_co_u32 v9, vcc_lo, v5, s6
	v_add_co_ci_u32_e32 v10, vcc_lo, s7, v6, vcc_lo
	s_delay_alu instid0(VALU_DEP_3)
	v_ldexp_f64 v[7:8], v[7:8], 0xffffffe0
	global_store_b64 v[9:10], v[7:8], off
.LBB3_18:                               ; %Flow
                                        ;   in Loop: Header=BB3_14 Depth=1
	s_or_b32 exec_lo, exec_lo, s1
	global_load_b64 v[7:8], v1, s[44:45]
	s_add_i32 s4, s4, 1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_mov_b64 s[6:7], s[4:5]
	s_waitcnt vmcnt(0)
	v_cmp_lt_i64_e32 vcc_lo, s[4:5], v[7:8]
	s_cbranch_vccnz .LBB3_14
.LBB3_19:                               ; %._crit_edge
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
		.amdhsa_group_segment_fixed_size 2560
		.amdhsa_private_segment_fixed_size 8
		.amdhsa_kernarg_size 280
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 1
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 52
		.amdhsa_next_free_sgpr 54
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end3:
	.size	_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl, .Lfunc_end3-_Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 1900
; NumSgprs: 56
; NumVgprs: 52
; ScratchSize: 8
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 2560 bytes/workgroup (compile time only)
; SGPRBlocks: 6
; VGPRBlocks: 6
; NumSGPRsForWavesPerEU: 56
; NumVGPRsForWavesPerEU: 52
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 1
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.p2alignl 7, 3214868480
	.fill 96, 4, 3214868480
	.type	__hip_cuid_,@object             ; @__hip_cuid_
	.section	.bss,"aw",@nobits
	.globl	__hip_cuid_
__hip_cuid_:
	.byte	0                               ; 0x0
	.size	__hip_cuid_, 1

	.ident	"AMD clang version 18.0.0git (https://github.com/RadeonOpenCompute/llvm-project roc-6.3.2 25012 e5bf7e55c91490b07c49d8960fa7983d864936c4)"
	.section	".note.GNU-stack","",@progbits
	.addrsig
	.addrsig_sym __hip_cuid_
	.amdgpu_metadata
---
amdhsa.kernels:
  - .args:
      - .address_space:  global
        .offset:         0
        .size:           8
        .value_kind:     global_buffer
      - .address_space:  global
        .offset:         8
        .size:           8
        .value_kind:     global_buffer
      - .address_space:  global
        .offset:         16
        .size:           8
        .value_kind:     global_buffer
      - .offset:         24
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         28
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         32
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         36
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         38
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         40
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         42
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         44
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         46
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         64
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         72
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         80
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         88
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 2560
    .kernarg_segment_align: 8
    .kernarg_segment_size: 280
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl
    .private_segment_fixed_size: 8
    .sgpr_count:     56
    .sgpr_spill_count: 0
    .symbol:         _Z28gq58x4_kernel_generate_arrayP12gq58x4_statePjPl.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     52
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .address_space:  global
        .offset:         0
        .size:           8
        .value_kind:     global_buffer
      - .address_space:  global
        .offset:         8
        .size:           8
        .value_kind:     global_buffer
      - .address_space:  global
        .offset:         16
        .size:           8
        .value_kind:     global_buffer
      - .offset:         24
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         28
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         32
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         36
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         38
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         40
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         42
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         44
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         46
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         64
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         72
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         80
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         88
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 2560
    .kernarg_segment_align: 8
    .kernarg_segment_size: 280
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl
    .private_segment_fixed_size: 8
    .sgpr_count:     56
    .sgpr_spill_count: 0
    .symbol:         _Z34gq58x4_kernel_generate_array_floatP12gq58x4_statePfPl.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     52
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .address_space:  global
        .offset:         0
        .size:           8
        .value_kind:     global_buffer
      - .address_space:  global
        .offset:         8
        .size:           8
        .value_kind:     global_buffer
      - .address_space:  global
        .offset:         16
        .size:           8
        .value_kind:     global_buffer
      - .offset:         24
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         28
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         32
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         36
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         38
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         40
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         42
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         44
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         46
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         64
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         72
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         80
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         88
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 2560
    .kernarg_segment_align: 8
    .kernarg_segment_size: 280
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl
    .private_segment_fixed_size: 8
    .sgpr_count:     56
    .sgpr_spill_count: 0
    .symbol:         _Z35gq58x4_kernel_generate_array_doubleP12gq58x4_statePdPl.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     52
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
amdhsa.target:   amdgcn-amd-amdhsa--gfx1100
amdhsa.version:
  - 1
  - 2
...

	.end_amdgpu_metadata
