#include <stdbool.h>


typedef struct{
int extent,mult,lower;
}Triplet;



typedef struct{
void*addr;
int offset;
Triplet dim[1];
}Dope1;

typedef struct{
void*addr;
int offset;
Triplet dim[2];
}Dope2;

typedef struct{
void*addr;
int offset;
Triplet dim[3];
}Dope3;

typedef struct{
void*addr;
int offset;
Triplet dim[4];
}Dope4;

typedef struct{
void*addr;
int offset;
Triplet dim[5];
}Dope5;

typedef struct{
void*addr;
int offset;
Triplet dim[6];
}Dope6;

typedef struct{
void*addr;
int offset;
Triplet dim[7];
}Dope7;







void makearraydescriptor_c_long1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_long_long1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_float1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_double1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_bool1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_signed_char1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_short1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_char1_(Dope1*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<1;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}




void makearraydescriptor_c_long2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_long_long2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_float2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_double2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_bool2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_signed_char2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_short2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_char2_(Dope2*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<2;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}




void makearraydescriptor_c_long3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_long_long3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_float3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_double3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_bool3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_signed_char3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_short3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_char3_(Dope3*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<3;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}




void makearraydescriptor_c_long4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_long_long4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_float4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_double4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_bool4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_signed_char4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_short4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_char4_(Dope4*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<4;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}




void makearraydescriptor_c_long5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_long_long5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
long long int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(long long int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (long long int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_float5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
float*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(float);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (float*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_double5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
double*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(double);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (double*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_bool5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
_Bool*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(_Bool);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (_Bool*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_signed_char5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
signed char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(signed char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (signed char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_short5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
short int*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(short int);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (short int*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}


void makearraydescriptor_c_char5_(Dope5*array,void*void_address,int lower_bounds[],int upper_bounds[],int strides[])
{


int dim,offset,size;
char*address,*offset_address;

offset= 0;
size= 1;
for(dim= 0;dim<5;dim++)
{
(array->dim[dim].lower)= lower_bounds[dim];

(array->dim[dim].mult)= strides[dim]*sizeof(char);
(array->dim[dim].extent)= upper_bounds[dim]-lower_bounds[dim]+1;
offset-= strides[dim]*lower_bounds[dim];
size*= (array->dim[dim].extent);
}

address= (char*)void_address;
offset_address= address+offset;
array->addr= void_address;

array->offset= (void*)address-(void*)offset_address;


}